Ai ML

jupyter notebook에서 dataframe 출력 옵션 변경

aimler — Wed, 31 Dec 2025 14:50:32 +0900

Jupyter notebook에서 보통은 Dataframe을 화면에 출력할 때는

display(dataframe.head()) 와 같은 코드를 사용합니다.

하지만 가끔은 내용을 복사하기 편하기 위해서 print(dataframe) 코드를 사용하는데요

출력하는 가로 길이가 길어질 경우 아래와 같이 줄바꿈이 발생합니다.

이럴 때

pd.set_option('display.expand_frame_repr', False)

코드를 적용하시면 아래와 같이 줄바꿈이 발생하지 않습니다.

2025-12-05 트래커

aimler — Fri, 5 Dec 2025 22:30:19 +0900

동작중인 89개 트래커 입니다.

http://0123456789nonexistent.com:80/announce

http://0d.kebhana.mx:443/announce

http://107.189.2.131:1337/announce

http://1337.abcvg.info:80/announce

http://138.124.183.78:6969/announce

http://140.235.237.23:6969/announce

http://167.253.78.20:8080/announce

http://185.230.4.150:1337/announce

http://193.31.26.113:6969/announce

http://211.75.205.188:6969/announce

http://34.94.76.146:1337/announce

http://34.94.76.146:2701/announce

http://34.94.76.146:2710/announce

http://34.94.76.146:443/announce

http://34.94.76.146:6969/announce

http://34.94.76.146:80/announce

http://35.227.59.57:11450/announce

http://35.227.59.57:2710/announce

http://35.227.59.57:6969/announce

http://35.227.59.57:80/announce

http://35.227.59.57:80/announce.php

http://45.13.119.213:6969/announce

http://95.217.167.10:6969/announce

http://bittorrent-tracker.e-n-c-r-y-p-t.net:1337/announce

http://bt.poletracker.org:2710/announce

http://bt1.xxxxbt.cc:6969/announce

http://buny.uk:6969/announce

http://extracker.dahrkael.net:6969/announce

http://home.yxgz.club:6969/announce

http://ipv4.rer.lol:2710/announce

http://open.trackerlist.xyz:80/announce

http://p4p.arenabg.com:1337/announce

http://retracker.spark-rostov.ru:80/announce

http://seeders-paradise.org:80/announce

http://servandroidkino.ru:80/announce

http://share.hkg-fansub.info:80/announce.php

http://shubt.net:2710/announce

http://t.overflow.biz:6969/announce

http://torrent.hificode.in:6969/announce

http://tracker.bittor.pw:1337/announce

http://tracker.bt-hash.com:80/announce

http://tracker.bt4g.com:2095/announce

http://tracker.bz:80/announce

http://tracker.corpscorp.online:80/announce

http://tracker.dmcomic.org:2710/announce

http://tracker.ghostchu-services.top:80/announce

http://tracker.ipv6tracker.org:80/announce

http://tracker.lintk.me:2710/announce

http://tracker.moxing.party:6969/announce

http://tracker.mywaifu.best:6969/announce

http://tracker.renfei.net:8080/announce

http://tracker.sbsub.com:2710/announce

http://tracker.tritan.gg:8080/announce

http://tracker.vanitycore.co:6969/announce

http://tracker.xiaoduola.xyz:6969/announce

http://tracker1.itzmx.com:8080/announce

http://tracker810.xyz:11450/announce

http://www.genesis-sp.org:2710/announce

http://www.torrentsnipe.info:2701/announce

https://tr.zukizuki.org:443/announce

https://tracker.bt4g.com:443/announce

https://tracker.ghostchu-services.top:443/announce

https://tracker.leechshield.link:443/announce

https://tracker.moeblog.cn:443/announce

https://tracker.pmman.tech:443/announce

https://tracker.yemekyedim.com:443/announce

udp://107.189.7.165:6969/announce

udp://111.90.151.241:6969/announce

udp://135.125.236.64:6969/announce

udp://176.99.7.59:6969/announce

udp://185.121.168.96:1337/announce

udp://185.243.218.213:80/announce

udp://193.42.111.57:9337/announce

udp://209.141.59.25:6969/announce

udp://211.75.205.187:80/announce

udp://211.75.205.188:6969/announce

udp://89.234.156.205:451/announce

udp://94.23.207.177:6969/announce

udp://bandito.byterunner.io:6969/announce

udp://d40969.acod.regrucolo.ru:6969/announce

udp://open.stealth.si:80/announce

udp://retracker.lanta.me:2710/announce

udp://retracker01-msk-virt.corbina.net:80/announce

udp://t.overflow.biz:6969/announce

udp://tr4ck3r.duckdns.org:6969/announce

udp://tracker.gmi.gd:6969/announce

udp://tracker.opentrackr.org:1337/announce

udp://tracker.qu.ax:6969/announce

udp://tracker2.dler.org:80/announce

ClickHouse 와 DuckDB / MySQL 과 비교

aimler — Fri, 14 Nov 2025 18:37:34 +0900

1. ClickHouse란 무엇인가?

ClickHouse는 Yandex가 개발한 컬럼 지향(Columnar) OLAP 데이터베이스입니다.
핵심 컨셉은:

초고속 읽기 성능 (OLAP 분석 쿼리)
압축률 우수
분산 처리 가능
실시간 분석(near real-time)

ClickHouse는 “데이터 웨어하우스 + 실시간 로그·이벤트 분석 엔진”의 중간 형태로 볼 수 있습니다.

대표적 사용처:

로그 분석 (ELK 대체)
모니터링/Metric 저장 (Prometheus 대체 가능)
이벤트 분석 (사용자 행동 로그)
대규모 시계열 데이터 처리
BI/OLAP 분석

2. ClickHouse vs MySQL 비교

구분	ClickHouse	MySQL
DB 유형	OLAP (컬럼 지향)	OLTP (행(Row) 지향)
목적	대규모 읽기/집계	실시간 트랜잭션
쓰기 성능	매우 빠름(배치 인서트 최적)	빠름(단건 트랜잭션 강함)
읽기 성능	대량 데이터 집계에 매우 강함	단건 조회/조인에 강함
인덱스	스킵 인덱스, 파티션, sparse index	B-Tree 인덱스
조인	제한적, 새로운 버전에서 개선됨	매우 강력
트랜잭션	거의 없음 (OLAP이므로)	ACID 준수
확장성	수평 확장 매우 우수	수평 확장 어려움
저장 구조	컬럼 저장 + 고압축	행 기반 저장
활용 적합성	로그, 이벤트 분석, 대용량 OLAP	주문/결제 시스템, ERP, CRUD 서비스

요약하면

MySQL → 서비스 DB(트랜잭션)
ClickHouse → 분석, 로그, 대규모 집계

특히 초당 수천만 로그를 넣고 바로 분석하는 구조에서는 ClickHouse가 MySQL을 압도적으로 능가합니다.

3. ClickHouse vs DuckDB 차이점

DuckDB와 ClickHouse는 둘 다 OLAP 엔진입니다. 그러나 철학이 완전히 다릅니다.

구분	ClickHouse	DuckDB
설계 철학	서버형 OLAP DB, 분산 확장	임베디드 OLAP 엔진, 파일 기반
설치 형태	서버/클러스터로 동작	Python·App에 포함되는 DB (SQLite처럼)
데이터 규모	수십~수백억 데이터	싱글 머신 메모리 범위
스토리지	서버 스토리지, S3 등	Parquet/CSV/Local 파일
사용 목적	로그 플랫폼, DW, 실시간 분석	로컬 데이터 분석, 파이프라인, 임시 쿼리
확장성	수평 확장 가능	단일 노드 중심
커넥션 방식	TCP/HTTP 서버	라이브러리 호출(duckdb.connect())
쓰기 방식	대량 배치 삽입 최적화	파일 스캔 기반 즉시 분석에 강함
운영 비용	운영 필요	운영 비용 거의 없음
쿼리 성능	대규모 데이터 집계 우수	소규모~중규모 데이터 분석 최강

가장 중요한 차이

ClickHouse = 서버 기반 고성능 분석 DB
DuckDB = 애플리케이션 내부 분석 엔진 (SQLite의 OLAP 버전)

둘 다 OLAP이지만
ClickHouse는 운영형(operational), DuckDB는 임베디드 분석형 입니다.

4. 어떤 상황에 어떤 DB를 써야 하는가?

ClickHouse 추천 상황

초당 수십만 ~ 수천만 로그 적재
엔터프라이즈 수준의 실시간 대시보드
Grafana, Kibana 대체
이벤트 분석(Amplitude/Mixpanel 대체)
분산 환경 필수

DuckDB 추천 상황

Python 기반 데이터 분석
CSV/Parquet 파일 분석
로그 파이프라인의 임시 ETL, 일시적 분석
서버 없이 로컬/단일 노드에서 빠른 분석

MySQL 추천 상황

CRUD 중심 서비스 DB
사용자/상품/결제 등 트랜잭션 중심
OLAP에는 부적합 (복잡한 집계가 느림)

5. 로그 분석을 기준으로 한 선택 가이드

로그 규모	추천
수십 GB 이하	DuckDB
수백 GB~수 TB (싱글 서버 가능)	ClickHouse
수 TB 이상 + 분산 필요	ClickHouse 클러스터
트랜잭션 로그 저장/일반 서비스 로그	MySQL(OLTP)
임시 분석/개발환경에서 분석	DuckDB

최종 요약

ClickHouse

고성능 컬럼 기반 OLAP DB
로그/이벤트/모니터링 분석에 최적
MySQL보다 훨씬 빠른 대규모 집계 성능

MySQL

트랜잭션(DBMS)
CRUD·조인 처리에 강함
OLAP·로그 분석은 적합하지 않음

DuckDB

로컬/임베디드 OLAP 엔진
파일 분석/ETL/개발환경에서 최강
ClickHouse처럼 서버·클러스터 운영은 불가능

시계열 데이터의 비정상성을 제거하기 위해 사용하는 잔차를 편차로 대체할 수 있는지 여

aimler — Fri, 14 Nov 2025 18:21:02 +0900

결론: 시계열에서 비정상성을 제거하려는 목적이라면 ‘잔차(residual)’ 대신 ‘편차(deviation)’를 사용하면 안됩니다.

이유는 편차는 비정상성을 제거하지 못하고, 잔차는 비정상성의 원인을 제거한 후 남는 신호이기 때문입니다.

1) “편차(deviation)”는 무엇인가?

편차 = 각 값에서 “전체 평균”을 뺀 값

문제는 이것입니다:

✔ 편차는 평균이 일정한 데이터(정상성)라는 전제를 필요로 한다

비정상 시계열은 보통 시간에 따라 평균이 변합니다(트렌드, 계절성).
그런데 편차는 단지 “전체 평균” 한 번 빼줄 뿐이기 때문에, 시간에 따라 바뀌는 패턴을 제거해 주지 못합니다.

즉,

편차는 트렌드도, 계절성도 제거하지 못합니다. 시계열이 비정상이라면 편차를 써도 비정상은 그대로 남습니다.

2) “잔차(residual)”는 무엇인가?

잔차 = 모델이 설명한 부분을 제거한 후 남은 값

✔ 잔차는 데이터에서 비정상성(트렌드·계절성)을 제거한 상태가 된다

즉,

잔차는 평균이 일정하고 분산이 비교적 안정된 정상 시계열을 얻기 위한 방법입니다.

3) 편차는 언제 사용하는가?

편차(평균 중심화)는 회귀나 PCA 같은 일반 머신러닝 전처리에서 쓰는 개념이지, 시계열 비정상성 제거 용도는 아닙니다.

단순히 스케일링을 위해 사용하는 것일 뿐
시간에 따른 패턴 제거 기능은 없음

4) 잔차를 쓰면 좋은 점

시계열 분해(STL, X11 등) → 잔차 = 비정상 요소 제거
ARIMA 학습 시 필수인 “정상성”을 만족시키기 쉬움
외생변수 영향 제거(회귀 후 잔차 사용)
계절성 제거 필수 분석(매출, 트래픽 등에서 매우 중요)

5) 핵심 결론

편차는 전체 평균만 제거하므로 비정상성 제거에 효과가 없다.
잔차는 트렌드·계절성·구조적 패턴을 제거하여 정상성에 근접한 데이터를 만든다.

그래서 시계열의 정상화를 목표로 한다면 반드시 **잔차(residual)**를 사용해야 합니다.

Fusion 나사산 별로 출력한 결과물 사진입니다.

aimler — Sun, 9 Nov 2025 22:16:48 +0900

3D 프린터로 출력할 제품을 설계하다 보면 나사산을 사용할 일이 자주 생깁니다.

그동안은 가장 일반적인 ISO 미터법 나사산 프로파일을 주로 사용해 왔지만,
상황에 따라 좀 더 폭이 넓은 나사산이 필요한 경우도 있었습니다.

그래서 이번 기회에 여러 종류의 나사산을 직접 출력해 비교해 보기로 했습니다.

Fusion의 나사산 목록입니다.

Bamublab A1 mini를 사용한 출력물 사진입니다.

출력물 Line별로 확대한 이미지입니다.

사내에서 Langchain 사용시 발생하는 SSL 오류 해결방법

aimler — Tue, 28 Oct 2025 14:16:01 +0900

사내에서 Langchain을 사용할 경우 아래와 같이 오류가 발생한다면 모듈 파일을 수정해서 오류를 우회할 수 있습니다.

✅ 코드

llm = ChatOpenAI(
    api_key="USER API Key",
    model="gpt-4o-mini" 
)

@tool
def get_weather(city: str) -> str:
    """Get weather for a given city.""" 
    return f"It's always sunny in {city}!" 

agent = create_agent(
    model=llm,
    tools=[get_weather],
    system_prompt="You are a helpful assistant",
)

# Run the agent
agent.invoke(
    {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
)

✅ 오류 내용

---------------------------------------------------------------------------
ConnectError                              Traceback (most recent call last)
File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_transports\default.py:101, in map_httpcore_exceptions()
    100 try:
--> 101     yield
    102 except Exception as exc:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_transports\default.py:250, in HTTPTransport.handle_request(self, request)
    249 with map_httpcore_exceptions():
--> 250     resp = self._pool.handle_request(req)
    252 assert isinstance(resp.stream, typing.Iterable)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_sync\connection_pool.py:256, in ConnectionPool.handle_request(self, request)
    255     self._close_connections(closing)
--> 256     raise exc from None
    258 # Return the response. Note that in this case we still have to manage
    259 # the point at which the response is closed.

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_sync\connection_pool.py:236, in ConnectionPool.handle_request(self, request)
    234 try:
    235     # Send the request on the assigned connection.
--> 236     response = connection.handle_request(
    237         pool_request.request
    238     )
    239 except ConnectionNotAvailable:
    240     # In some cases a connection may initially be available to
    241     # handle a request, but then become unavailable.
    242     #
    243     # In this case we clear the connection and try again.

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_sync\connection.py:101, in HTTPConnection.handle_request(self, request)
    100     self._connect_failed = True
--> 101     raise exc
    103 return self._connection.handle_request(request)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_sync\connection.py:78, in HTTPConnection.handle_request(self, request)
     77 if self._connection is None:
---> 78     stream = self._connect(request)
     80     ssl_object = stream.get_extra_info("ssl_object")

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_sync\connection.py:156, in HTTPConnection._connect(self, request)
    155 with Trace("start_tls", logger, request, kwargs) as trace:
--> 156     stream = stream.start_tls(**kwargs)
    157     trace.return_value = stream

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_backends\sync.py:154, in SyncStream.start_tls(self, ssl_context, server_hostname, timeout)
    150 exc_map: ExceptionMapping = {
    151     socket.timeout: ConnectTimeout,
    152     OSError: ConnectError,
    153 }
--> 154 with map_exceptions(exc_map):
    155     try:

File c:\Users\User\.conda\envs\Orange\Lib\contextlib.py:158, in _GeneratorContextManager.__exit__(self, typ, value, traceback)
    157 try:
--> 158     self.gen.throw(value)
    159 except StopIteration as exc:
    160     # Suppress StopIteration *unless* it's the same exception that
    161     # was passed to throw().  This prevents a StopIteration
    162     # raised inside the "with" statement from being suppressed.

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpcore\_exceptions.py:14, in map_exceptions(map)
     13     if isinstance(exc, from_exc):
---> 14         raise to_exc(exc) from exc
     15 raise

ConnectError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1000)

The above exception was the direct cause of the following exception:

ConnectError                              Traceback (most recent call last)
File c:\Users\User\.conda\envs\Orange\Lib\site-packages\openai\_base_client.py:982, in SyncAPIClient.request(self, cast_to, options, stream, stream_cls)
    981 try:
--> 982     response = self._client.send(
    983         request,
    984         stream=stream or self._should_stream_response_body(request=request),
    985         **kwargs,
    986     )
    987 except httpx.TimeoutException as err:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_client.py:914, in Client.send(self, request, stream, auth, follow_redirects)
    912 auth = self._build_request_auth(request, auth)
--> 914 response = self._send_handling_auth(
    915     request,
    916     auth=auth,
    917     follow_redirects=follow_redirects,
    918     history=[],
    919 )
    920 try:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_client.py:942, in Client._send_handling_auth(self, request, auth, follow_redirects, history)
    941 while True:
--> 942     response = self._send_handling_redirects(
    943         request,
    944         follow_redirects=follow_redirects,
    945         history=history,
    946     )
    947     try:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_client.py:979, in Client._send_handling_redirects(self, request, follow_redirects, history)
    977     hook(request)
--> 979 response = self._send_single_request(request)
    980 try:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_client.py:1014, in Client._send_single_request(self, request)
   1013 with request_context(request=request):
-> 1014     response = transport.handle_request(request)
   1016 assert isinstance(response.stream, SyncByteStream)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_transports\default.py:249, in HTTPTransport.handle_request(self, request)
    237 req = httpcore.Request(
    238     method=request.method,
    239     url=httpcore.URL(
   (...)    247     extensions=request.extensions,
    248 )
--> 249 with map_httpcore_exceptions():
    250     resp = self._pool.handle_request(req)

File c:\Users\User\.conda\envs\Orange\Lib\contextlib.py:158, in _GeneratorContextManager.__exit__(self, typ, value, traceback)
    157 try:
--> 158     self.gen.throw(value)
    159 except StopIteration as exc:
    160     # Suppress StopIteration *unless* it's the same exception that
    161     # was passed to throw().  This prevents a StopIteration
    162     # raised inside the "with" statement from being suppressed.

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_transports\default.py:118, in map_httpcore_exceptions()
    117 message = str(exc)
--> 118 raise mapped_exc(message) from exc

ConnectError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1000)

The above exception was the direct cause of the following exception:

APIConnectionError                        Traceback (most recent call last)
Cell In[3], line 17
     10 agent = create_agent(
     11     model=llm,
     12     tools=[get_weather],
     13     system_prompt="You are a helpful assistant",
     14 )
     16 # Run the agent
---> 17 agent.invoke(
     18     {"messages": [{"role": "user", "content": "what is the weather in sf"}]}
     19 )

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langgraph\pregel\main.py:3094, in Pregel.invoke(self, input, config, context, stream_mode, print_mode, output_keys, interrupt_before, interrupt_after, durability, **kwargs)
   3091 chunks: list[dict[str, Any] | Any] = []
   3092 interrupts: list[Interrupt] = []
-> 3094 for chunk in self.stream(
   3095     input,
   3096     config,
   3097     context=context,
   3098     stream_mode=["updates", "values"]
   3099     if stream_mode == "values" 
   3100     else stream_mode,
   3101     print_mode=print_mode,
   3102     output_keys=output_keys,
   3103     interrupt_before=interrupt_before,
   3104     interrupt_after=interrupt_after,
   3105     durability=durability,
   3106     **kwargs,
   3107 ):
   3108     if stream_mode == "values":
   3109         if len(chunk) == 2:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langgraph\pregel\main.py:2679, in Pregel.stream(self, input, config, context, stream_mode, print_mode, output_keys, interrupt_before, interrupt_after, durability, subgraphs, debug, **kwargs)
   2677 for task in loop.match_cached_writes():
   2678     loop.output_writes(task.id, task.writes, cached=True)
-> 2679 for _ in runner.tick(
   2680     [t for t in loop.tasks.values() if not t.writes],
   2681     timeout=self.step_timeout,
   2682     get_waiter=get_waiter,
   2683     schedule_task=loop.accept_push,
   2684 ):
   2685     # emit output
   2686     yield from _output(
   2687         stream_mode, print_mode, subgraphs, stream.get, queue.Empty
   2688     )
   2689 loop.after_tick()

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langgraph\pregel\_runner.py:167, in PregelRunner.tick(self, tasks, reraise, timeout, retry_policy, get_waiter, schedule_task)
    165 t = tasks[0]
    166 try:
--> 167     run_with_retry(
    168         t,
    169         retry_policy,
    170         configurable={
    171             CONFIG_KEY_CALL: partial(
    172                 _call,
    173                 weakref.ref(t),
    174                 retry_policy=retry_policy,
    175                 futures=weakref.ref(futures),
    176                 schedule_task=schedule_task,
    177                 submit=self.submit,
    178             ),
    179         },
    180     )
    181     self.commit(t, None)
    182 except Exception as exc:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langgraph\pregel\_retry.py:42, in run_with_retry(task, retry_policy, configurable)
     40     task.writes.clear()
     41     # run the task
---> 42     return task.proc.invoke(task.input, config)
     43 except ParentCommand as exc:
     44     ns: str = config[CONF][CONFIG_KEY_CHECKPOINT_NS]

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langgraph\_internal\_runnable.py:656, in RunnableSeq.invoke(self, input, config, **kwargs)
    654     # run in context
    655     with set_config_context(config, run) as context:
--> 656         input = context.run(step.invoke, input, config, **kwargs)
    657 else:
    658     input = step.invoke(input, config)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langgraph\_internal\_runnable.py:400, in RunnableCallable.invoke(self, input, config, **kwargs)
    398         run_manager.on_chain_end(ret)
    399 else:
--> 400     ret = self.func(*args, **kwargs)
    401 if self.recurse and isinstance(ret, Runnable):
    402     return ret.invoke(input, config)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain\agents\factory.py:1034, in create_agent.<locals>.model_node(state, runtime)
   1021 request = ModelRequest(
   1022     model=model,
   1023     tools=default_tools,
   (...)   1029     runtime=runtime,
   1030 )
   1032 if wrap_model_call_handler is None:
   1033     # No handlers - execute directly
-> 1034     response = _execute_model_sync(request)
   1035 else:
   1036     # Call composed handler with base handler
   1037     response = wrap_model_call_handler(request, _execute_model_sync)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain\agents\factory.py:1007, in create_agent.<locals>._execute_model_sync(request)
   1004 if request.system_prompt:
   1005     messages = [SystemMessage(request.system_prompt), *messages]
-> 1007 output = model_.invoke(messages)
   1009 # Handle model output to get messages and structured_response
   1010 handled_output = _handle_model_output(output, effective_response_format)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_core\runnables\base.py:5489, in RunnableBindingBase.invoke(self, input, config, **kwargs)
   5482 @override
   5483 def invoke(
   5484     self,
   (...)   5487     **kwargs: Any | None,
   5488 ) -> Output:
-> 5489     return self.bound.invoke(
   5490         input,
   5491         self._merge_configs(config),
   5492         **{**self.kwargs, **kwargs},
   5493     )

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_core\language_models\chat_models.py:379, in BaseChatModel.invoke(self, input, config, stop, **kwargs)
    365 @override
    366 def invoke(
    367     self,
   (...)    372     **kwargs: Any,
    373 ) -> AIMessage:
    374     config = ensure_config(config)
    375     return cast(
    376         "AIMessage",
    377         cast(
    378             "ChatGeneration",
--> 379             self.generate_prompt(
    380                 [self._convert_input(input)],
    381                 stop=stop,
    382                 callbacks=config.get("callbacks"),
    383                 tags=config.get("tags"),
    384                 metadata=config.get("metadata"),
    385                 run_name=config.get("run_name"),
    386                 run_id=config.pop("run_id", None),
    387                 **kwargs,
    388             ).generations[0][0],
    389         ).message,
    390     )

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_core\language_models\chat_models.py:1088, in BaseChatModel.generate_prompt(self, prompts, stop, callbacks, **kwargs)
   1079 @override
   1080 def generate_prompt(
   1081     self,
   (...)   1085     **kwargs: Any,
   1086 ) -> LLMResult:
   1087     prompt_messages = [p.to_messages() for p in prompts]
-> 1088     return self.generate(prompt_messages, stop=stop, callbacks=callbacks, **kwargs)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_core\language_models\chat_models.py:903, in BaseChatModel.generate(self, messages, stop, callbacks, tags, metadata, run_name, run_id, **kwargs)
    900 for i, m in enumerate(input_messages):
    901     try:
    902         results.append(
--> 903             self._generate_with_cache(
    904                 m,
    905                 stop=stop,
    906                 run_manager=run_managers[i] if run_managers else None,
    907                 **kwargs,
    908             )
    909         )
    910     except BaseException as e:
    911         if run_managers:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_core\language_models\chat_models.py:1192, in BaseChatModel._generate_with_cache(self, messages, stop, run_manager, **kwargs)
   1190     result = generate_from_stream(iter(chunks))
   1191 elif inspect.signature(self._generate).parameters.get("run_manager"):
-> 1192     result = self._generate(
   1193         messages, stop=stop, run_manager=run_manager, **kwargs
   1194     )
   1195 else:
   1196     result = self._generate(messages, stop=stop, **kwargs)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_openai\chat_models\base.py:1300, in BaseChatOpenAI._generate(self, messages, stop, run_manager, **kwargs)
   1298     if raw_response is not None and hasattr(raw_response, "http_response"):
   1299         e.response = raw_response.http_response  # type: ignore[attr-defined]
-> 1300     raise e
   1301 if (
   1302     self.include_response_headers
   1303     and raw_response is not None
   1304     and hasattr(raw_response, "headers")
   1305 ):
   1306     generation_info = {"headers": dict(raw_response.headers)}

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\langchain_openai\chat_models\base.py:1295, in BaseChatOpenAI._generate(self, messages, stop, run_manager, **kwargs)
   1288         return _construct_lc_result_from_responses_api(
   1289             response,
   1290             schema=original_schema_obj,
   1291             metadata=generation_info,
   1292             output_version=self.output_version,
   1293         )
   1294     else:
-> 1295         raw_response = self.client.with_raw_response.create(**payload)
   1296         response = raw_response.parse()
   1297 except Exception as e:

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\openai\_legacy_response.py:364, in to_raw_response_wrapper.<locals>.wrapped(*args, **kwargs)
    360 extra_headers[RAW_RESPONSE_HEADER] = "true" 
    362 kwargs["extra_headers"] = extra_headers
--> 364 return cast(LegacyAPIResponse[R], func(*args, **kwargs))

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\openai\_utils\_utils.py:286, in required_args.<locals>.inner.<locals>.wrapper(*args, **kwargs)
    284             msg = f"Missing required argument: {quote(missing[0])}" 
    285     raise TypeError(msg)
--> 286 return func(*args, **kwargs)

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\openai\resources\chat\completions\completions.py:1156, in Completions.create(self, messages, model, audio, frequency_penalty, function_call, functions, logit_bias, logprobs, max_completion_tokens, max_tokens, metadata, modalities, n, parallel_tool_calls, prediction, presence_penalty, prompt_cache_key, reasoning_effort, response_format, safety_identifier, seed, service_tier, stop, store, stream, stream_options, temperature, tool_choice, tools, top_logprobs, top_p, user, verbosity, web_search_options, extra_headers, extra_query, extra_body, timeout)
   1110 @required_args(["messages", "model"], ["messages", "model", "stream"])
   1111 def create(
   1112     self,
   (...)   1153     timeout: float | httpx.Timeout | None | NotGiven = not_given,
   1154 ) -> ChatCompletion | Stream[ChatCompletionChunk]:
   1155     validate_response_format(response_format)
-> 1156     return self._post(
   1157         "/chat/completions",
   1158         body=maybe_transform(
   1159             {
   1160                 "messages": messages,
   1161                 "model": model,
   1162                 "audio": audio,
   1163                 "frequency_penalty": frequency_penalty,
   1164                 "function_call": function_call,
   1165                 "functions": functions,
   1166                 "logit_bias": logit_bias,
   1167                 "logprobs": logprobs,
   1168                 "max_completion_tokens": max_completion_tokens,
   1169                 "max_tokens": max_tokens,
   1170                 "metadata": metadata,
   1171                 "modalities": modalities,
   1172                 "n": n,
   1173                 "parallel_tool_calls": parallel_tool_calls,
   1174                 "prediction": prediction,
   1175                 "presence_penalty": presence_penalty,
   1176                 "prompt_cache_key": prompt_cache_key,
   1177                 "reasoning_effort": reasoning_effort,
   1178                 "response_format": response_format,
   1179                 "safety_identifier": safety_identifier,
   1180                 "seed": seed,
   1181                 "service_tier": service_tier,
   1182                 "stop": stop,
   1183                 "store": store,
   1184                 "stream": stream,
   1185                 "stream_options": stream_options,
   1186                 "temperature": temperature,
   1187                 "tool_choice": tool_choice,
   1188                 "tools": tools,
   1189                 "top_logprobs": top_logprobs,
   1190                 "top_p": top_p,
   1191                 "user": user,
   1192                 "verbosity": verbosity,
   1193                 "web_search_options": web_search_options,
   1194             },
   1195             completion_create_params.CompletionCreateParamsStreaming
   1196             if stream
   1197             else completion_create_params.CompletionCreateParamsNonStreaming,
   1198         ),
   1199         options=make_request_options(
   1200             extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
   1201         ),
   1202         cast_to=ChatCompletion,
   1203         stream=stream or False,
   1204         stream_cls=Stream[ChatCompletionChunk],
   1205     )

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\openai\_base_client.py:1259, in SyncAPIClient.post(self, path, cast_to, body, options, files, stream, stream_cls)
   1245 def post(
   1246     self,
   1247     path: str,
   (...)   1254     stream_cls: type[_StreamT] | None = None,
   1255 ) -> ResponseT | _StreamT:
   1256     opts = FinalRequestOptions.construct(
   1257         method="post", url=path, json_data=body, files=to_httpx_files(files), **options
   1258     )
-> 1259     return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls))

File c:\Users\User\.conda\envs\Orange\Lib\site-packages\openai\_base_client.py:1014, in SyncAPIClient.request(self, cast_to, options, stream, stream_cls)
   1011         continue
   1013     log.debug("Raising connection error")
-> 1014     raise APIConnectionError(request=request) from err
   1016 log.debug(
   1017     'HTTP Response: %s %s "%i %s" %s',
   1018     request.method,
   (...)   1022     response.headers,
   1023 )
   1024 log.debug("request_id: %s", response.headers.get("x-request-id"))

APIConnectionError: Connection error.
During task with name 'model' and id '165fa95b-????-????-????-????209ef8c5'

☑️ 해결 방법

C:\Users\User\.conda\envs\Orange\Lib\site-packages\httpx\_transports\default.py

모듈이 설치된 폴더로 이동하여 default.py를 아래와 같이 수정합니다.

class HTTPTransport(BaseTransport):
    def __init__(
        self,
        verify: ssl.SSLContext | str | bool = True,
        cert: CertTypes | None = None,
        trust_env: bool = True,
        http1: bool = True,
        http2: bool = False,
        limits: Limits = DEFAULT_LIMITS,
        proxy: ProxyTypes | None = None,
        uds: str | None = None,
        local_address: str | None = None,
        retries: int = 0,
        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
    ) -> None:
        import httpcore
        verify=False    # TODO 강제 False설정
        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 생략 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

class AsyncHTTPTransport(AsyncBaseTransport):
    def __init__(
        self,
        verify: ssl.SSLContext | str | bool = True,
        cert: CertTypes | None = None,
        trust_env: bool = True,
        http1: bool = True,
        http2: bool = False,
        limits: Limits = DEFAULT_LIMITS,
        proxy: ProxyTypes | None = None,
        uds: str | None = None,
        local_address: str | None = None,
        retries: int = 0,
        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
    ) -> None:
        import httpcore
        verify=False    # TODO 강제 False설정
        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
        
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~ 생략 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

Python @dataclass 데코레이터

aimler — Tue, 30 Sep 2025 23:01:30 +0900

@dataclass 는 데이터 전용 클래스를 쉽게 만들 수 있도록 도와주는 데코레이터입니다.

보통 우리가 단순히 데이터를 담는 용도로 클래스를 정의할 때는 __init__, __repr__, __eq__ 같은 메서드를 일일이 작성해야 했습니다. 하지만 @dataclass를 사용하면 이런 메서드를 자동 생성해 줍니다.

> 기본 개념

from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    active: bool = True

이렇게 작성하면 파이썬이 자동으로 다음을 생성합니다:

__init__ → User(id, name, active) 자동 정의
__repr__ → User(id=1, name='Alice', active=True) 형태의 문자열 반환
__eq__ → 객체끼리 값 비교 가능 (== 연산자)

> 사용 예시

user1 = User(1, "Alice")
user2 = User(2, "Bob", False)

print(user1)   # User(id=1, name='Alice', active=True)
print(user2)   # User(id=2, name='Bob', active=False)

print(user1 == User(1, "Alice"))  # True (값 비교)

> 주요 옵션

@dataclass 데코레이터는 여러 인자를 가질 수 있습니다:

frozen=True
→ 불변 객체(immutable)로 만듦 (값 변경 불가, dataclass 버전의 namedtuple 느낌)
eq=True/False
→ __eq__ 자동 생성 여부
order=True
→ <, >, <=, >= 비교 연산 지원
init=True/False
→ __init__ 생성 여부

> 예시

@dataclass(frozen=True, order=True)
class Point:
    x: int
    y: int

p1 = Point(1, 2)
p2 = Point(2, 3)

print(p1 < p2)  # True (order=True 덕분에 지원)
# p1.x = 10  # 에러 발생 (frozen=True 덕분에 불변 객체)

> field() 활용

필드별로 세부 설정도 가능합니다.

from dataclasses import dataclass, field

@dataclass
class Product:
    name: str
    price: float
    tags: list[str] = field(default_factory=list)  # 리스트는 반드시 default_factory 사용

이렇게 하면 각 인스턴스가 서로 다른 리스트 객체를 가지게 됩니다.
(default=[]로 쓰면 모든 인스턴스가 같은 리스트 공유 → 버그 발생 위험)

------------------------------------------------- 일반 클래스와 비교 -------------------------------------------------

> 일반 클래스 구현

class User:
    def __init__(self, id: int, name: str, active: bool = True):
        self.id = id
        self.name = name
        self.active = active

    def __repr__(self):
        return f"User(id={self.id!r}, name={self.name!r}, active={self.active!r})"

    def __eq__(self, other):
        if isinstance(other, User):
            return (self.id, self.name, self.active) == (other.id, other.name, other.active)
        return False


# 사용 예시
u1 = User(1, "Alice")
u2 = User(1, "Alice")

print(u1)        # User(id=1, name='Alice', active=True)
print(u1 == u2)  # True

일반 클래스는 __init__, __repr__, __eq__ 메서드를 직접 작성해야 합니다.

Opensource 게시판/포럼 솔루션

aimler — Tue, 2 Sep 2025 20:57:14 +0900

1. Discourse
    • 언어/기술: Ruby on Rails + Ember.js
    • 특징: 현대적인 UI, 모바일 친화적, 소셜 네트워크 느낌의 토론 게시판.
    • 장점:
        ◦ 알림, @멘션, 실시간 업데이트 지원
        ◦ 플러그인/테마로 확장성 높음
        ◦ SSO, OAuth, LDAP 등 연동 가능
    • 추천 대상: 최신형 커뮤니티, 기술 포럼, 고객 지원 Q&A 운영하려는 팀.

• 홈페이지: https://www.discourse.org

• Git: https://github.com/discourse

2. NodeBB
    • 언어/기술: Node.js + MongoDB/Redis
    • 특징: 빠르고 반응성 좋은 포럼, 실시간 알림 및 WebSocket 기반.
    • 장점:
        ◦ Slack/Discord 같은 느낌의 인터랙션
        ◦ 플러그인 마켓 풍부
        ◦ Docker 설치 지원
    • 추천 대상: 채팅·SNS와 유사한 경험을 원하거나, Node.js 환경에 익숙한 개발팀.
    • 홈페이지: https://nodebb.org

• Git: https://github.com/NodeBB

3. Flarum
    • 언어/기술: PHP + MySQL
    • 특징: 미니멀하고 빠른 차세대 포럼. “심플한 Discourse” 느낌.
    • 장점:
        ◦ 확장 플러그인 생태계 존재
        ◦ 모바일 대응 우수
        ◦ 설치가 비교적 간단 (PHP 환경이면 OK)
    • 추천 대상: 가볍고 심플한 커뮤니티를 빠르게 구축하려는 소규모 팀/동호회.
    • 홈페이지: https://flarum.org

• Git: https://github.com/flarum

4. MyBB
    • 언어/기술: PHP + MySQL
    • 특징: 전통적인 게시판 스타일 (네이버 카페·phpBB 같은 느낌).
    • 장점:
        ◦ 오래된 안정적인 프로젝트, 한글화 자료 풍부
        ◦ 플러그인/테마 다양
        ◦ 전통적인 게시판 UI에 익숙한 사용자에게 친숙
    • 추천 대상: 학급/동호회 커뮤니티, 게임 길드 포럼 등 전통적 게시판 선호 시.
    • 홈페이지: https://mybb.com

• Git: https://github.com/mybb

5. phpBB
    • 언어/기술: PHP + MySQL/PostgreSQL
    • 특징: 가장 오래된 오픈소스 포럼 중 하나. 커뮤니티 규모가 큼.
    • 장점:
        ◦ 방대한 플러그인/테마
        ◦ 유저 권한 관리가 매우 세밀함
        ◦ 대규모 포럼 운영에 검증된 솔루션
    • 추천 대상: 대형 커뮤니티, 장기간 안정적인 운영이 필요한 경우.
    • 홈페이지: https://www.phpbb.com

• Git: https://github.com/phpbb

6. Vanilla Forums (오픈소스 버전)
    • 언어/기술: PHP
    • 특징: 현대적인 UI + 소셜 기능. 기업용 상용 버전도 존재.
    • 장점:
        ◦ 깔끔한 인터페이스
        ◦ 기본 기능 충실
        ◦ 커머스·서포트 포럼 운영에도 적합
    • 추천 대상: 기업용 커뮤니티, 고객지원 포럼.

• 홈페이지: https://open.vanillaforums.com

• Git: https://github.com/vanilla

솔루션	특징 요약	추천 대상	기술
Discourse	현대적, 실시간, 확장성 강력	기술 포럼, 고객지원	Ruby on Rails + Ember.js
NodeBB	Node.js 기반, 빠르고 채팅 느낌	개발팀, 실시간 커뮤니티	Node.js + MongoDB/Redis
Flarum	가볍고 미니멀, 모바일 최적화	소규모 동호회, 심플 커뮤니티	PHP + MySQL
MyBB	전통 게시판 스타일, 한글화 용이	학급, 게임, 전통 포럼	PHP + MySQL
phpBB	검증된 대형 포럼 엔진	대형 커뮤니티 운영	PHP + MySQL/PostgreSQL
Vanilla Forums	기업/브랜드 커뮤니티 적합	기업 고객지원 포럼	PHP

Redmine의 대안으로 사용할 수 있는 Opensource 플랫폼 소개

aimler — Tue, 2 Sep 2025 20:35:56 +0900

1. OpenProject
• 특징: Gantt 차트, 칸반·스크럼 보드, 시간 추적, 이슈 및 문서 관리 등 종합 프로젝트 관리 기능 제공. 모던한 UI와 높은 보안성을 갖춘 온프레미스/클라우드 배포 모두 가능
  • 장점:
  ◦ 사용자 친화적인 디자인과 상세한 온보딩/문서 지원
  ◦ 워크플로우 전반을 하나의 플랫폼에서 관리 가능
  • 활용 사례: 건설업, 헬스케어 등 민감한 도메인에서도 선호됨
  • 주의사항: 커뮤니티 에디션의 기능 제한과 다소 높은 학습 곡선 존재

• 홈페이지: https://www.openproject.org/

2. Taiga
  • 특징: 스크럼과 칸반 중심의 애자일 방식 프로젝트 관리에 특화된 시스템. 직관적인 UI와 가벼운 구조가 장점
  • 장점:
  ◦ 백로그, 스프린트, 이슈 트래킹 등 애자일 팀에 최적화된 기능
  ◦ 쉬운 설치 및 다양한 언어 지원.
  • 주의사항: 고급 프로젝트 관리 기능이나 복잡한 워크플로우에는 한계 있을 수 있음.
  •  홈페이지: https://taiga.io/

3. Kanboard
  • 특징: 초경량 칸반 보드 기반. 단순하고 효율적인 작업 시각화에 최적화된 도구
  • 장점:
  ◦ 드래그 앤 드롭 UI, 자동화, CLI 등 심플하지만 필요한 기능 제공.
  ◦ 도커 환경에서도 쉽게 운영 가능.
  • 주의사항: 기능이 칸반 중심으로 제한적이며 모바일 앱은 없음
  •  홈페이지: https://kanboard.org/

4. Trac
  • 특징: 이슈 추적, 버전 관리(Git/SVN) 통합, 위키와 간단한 로드맵 기능을 제공하는 웹 기반 관리 시스템
  • 장점:
◦ 프로젝트 일정, 티켓, 위키 간 하이퍼링크로 유기적 통합.
  ◦ 타임라인, RSS/이메일 알림, 상세 권한 관리 기능 탑재.
  • 활용 사례: Django, FFmpeg, WordPress 등 다양한 오픈소스 프로젝트에서 사용
  • 주의사항: UI가 다소 전통적이며, 현대적인 인터페이스를 선호하는 경우 아쉬울 수 있음.
  •  홈페이지: https://trac.edgewall.org/

5. ProjeQtOr
  • 특징: '품질 중심 프로젝트 조직(Quality based Project Organizer)'이라는 슬로건으로, 리스크 관리, 예산/비용, 보고서, 워크플로우 기능 등 다양한 기능 제공
  • 장점:
  ◦ 다국어 지원, 멀티 플랫폼.
  • 주의사항: 설정이 다소 복잡할 수 있으며, UI도 전통적일 수 있음.

• 홈페이지: https://www.projeqtor.org/en/product-en

6. WorkLenz

• 특징: 오픈소스 워크플로우 관리 도구로, HR 및 CRM 모듈 포함. GitHub에서 꾸준히 활발하게 개발 중

• 홈페이지: https://worklenz.com/

플랫폼	특징 요약	추천 대상
OpenProject	종합 기능 + 모던 UI	보안 및 기능성을 중시하는 조직
Taiga	애자일 중심, 직관적인 인터페이스	애자일팀, 스타트업
Kanboard	간단 칸반 방식	심플한 작업 시각화가 필요한 소규모 팀
Trac	이슈+버전+위키 통합	개발자 중심 프로젝트, 오픈소스 기반 프로젝트
ProjeQtOr	리스크/예산 관리 등 품질 중심 특화	예산/리스크 관리가 중요한 조직
WorkLenz	HR/CRM 모듈 통합 등 특별 기능 제공	다기능 커스터마이징이 필요한 팀

Grafana 에서 Business Charts의 캔들차트 표시하는 방법

aimler — Fri, 29 Aug 2025 17:27:35 +0900

Grafana에서 주식차트를 그리는 방법을 설명드립니다.

데이터 구조만 맞춰주시고 javascript 코드는 그대로 사용하시면 아래와 같은 그래프가 표시됩니다.

차트

데이터 구조

Javascript 코드입니다.

const rawData = [];
context.panel.data.series.forEach((series) => {
  const event_dates_Field = series.fields.find(f => f.name.toLowerCase().includes("event_date"));	// 날짜
  const openingPrices_Field = series.fields.find(f => f.name.toLowerCase().includes("openingprice"));	// 시가
  const tradePrices_Field = series.fields.find(f => f.name.toLowerCase().includes("tradeprice"));	// 종가
  const lowPrices_Field = series.fields.find(f => f.name.toLowerCase().includes("lowprice"));	// 저가
  const highPrices_Field = series.fields.find(f => f.name.toLowerCase().includes("highprice"));	// 고가
  if (!event_dates_Field || !openingPrices_Field || !tradePrices_Field || !lowPrices_Field || !highPrices_Field) return;

  const event_dates = event_dates_Field.values;
  const openingPrices = openingPrices_Field.values;
  const tradePrices = tradePrices_Field.values;
  const lowPrices = lowPrices_Field.values;
  const highPrices = highPrices_Field.values;

  for (let i = 0; i < event_dates.length; i++) {
    rawData.push([
      event_dates.get(i).toString(),
      openingPrices.get(i).toString(),
      tradePrices.get(i).toString(),
      lowPrices.get(i).toString(),
      highPrices.get(i).toString()
    ]);
  }
});
// console.log(rawData);
function calculateMA(dayCount, data) {
  var result = [];
  for (var i = 0, len = data.length; i < len; i++) {
    if (i < dayCount) {
      result.push('-');
      continue;
    }
    var sum = 0;
    for (var j = 0; j < dayCount; j++) {
      sum += +data[i - j][1];
    }
    result.push(sum / dayCount);
  }
  return result;
}
const dates = rawData.map(function (item) {
  return item[0];	// 날짜
});
const values = rawData.map(function (item) {
  return [+item[1], +item[2], +item[3], +item[4]];	// 시가(1), 종가(2), 저가(3), 고가(4)
});

return {
  legend: {
    data: ['日K', 'MA5', 'MA10', 'MA20', 'MA30'],
    inactiveColor: '#777'
  },
  tooltip: {
    trigger: 'axis',
    axisPointer: {
      animation: false,
      type: 'cross',
      lineStyle: {
        color: '#376df4',
        width: 2,
        opacity: 1
      }
    }
  },
  xAxis: {
    type: 'category',
    data: dates,
    axisLine: { lineStyle: { color: '#8392A5' } }
  },
  yAxis: {
    scale: true,
    axisLine: { lineStyle: { color: '#8392A5' } },
    splitLine: { show: false }
  },
  grid: {
    bottom: 80
  },
  dataZoom: [
    {
      textStyle: {
        color: '#8392A5'
      },
      handleIcon:
        'path://M10.7,11.9v-1.3H9.3v1.3c-4.9,0.3-8.8,4.4-8.8,9.4c0,5,3.9,9.1,8.8,9.4v1.3h1.3v-1.3c4.9-0.3,8.8-4.4,8.8-9.4C19.5,16.3,15.6,12.2,10.7,11.9z M13.3,24.4H6.7V23h6.6V24.4z M13.3,19.6H6.7v-1.4h6.6V19.6z',
      dataBackground: {
        areaStyle: {
          color: '#8392A5'
        },
        lineStyle: {
          opacity: 0.8,
          color: '#8392A5'
        }
      },
      brushSelect: true
    },
    {
      type: 'inside'
    }
  ],
  series: [
    {
      type: 'candlestick',
      name: 'Day',
      data: values,
      itemStyle: {
        color: '#FD1050',
        color0: '#0CF49B',
        borderColor: '#FD1050',
        borderColor0: '#0CF49B'
      }
    },
    {
      name: 'MA5',
      type: 'line',
      data: calculateMA(5, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    },
    {
      name: 'MA10',
      type: 'line',
      data: calculateMA(10, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    },
    {
      name: 'MA20',
      type: 'line',
      data: calculateMA(20, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    },
    {
      name: 'MA30',
      type: 'line',
      data: calculateMA(30, values),
      smooth: true,
      showSymbol: false,
      lineStyle: {
        width: 1
      }
    }
  ]
};

dbt 명칭을 왜 소문자로 표기할까?

aimler — Tue, 19 Aug 2025 10:25:59 +0900

사실 dbt는 정식 명칭이 “data build tool”인데, dbt Labs에서는 일부러 소문자 표기(db t)를 고수합니다.

이유

1. 브랜딩 철학

dbt Labs는 “데이터팀을 위한 도구가 거창한 이름이 아니라, 가볍고 실용적인 툴”이라는 이미지를 주고 싶었습니다.
그래서 일반적인 약자처럼 “DBT”라고 대문자로 쓰지 않고, 소문자 dbt라는 독특한 스타일을 선택했습니다.

2. 개발자 문화와 유사성

리눅스 명령어나 Python 패키지 이름처럼, 소문자 CLI(command-line interface) 툴 스타일을 따랐습니다.
실제로 설치 후 실행할 때도 dbt run, dbt test처럼 소문자 명령어를 입력합니다.

3. 공식 가이드라인

dbt Labs 공식 문서에서도 “항상 dbt라고 소문자로 작성할 것”을 권장합니다. 가이드

대문자 DBT는 다른 의미(예: 심리치료에서 쓰이는 Dialectical Behavior Therapy)와 혼동될 수 있기 때문에 차별화 목적도 있습니다.

ETL vs ELT 비교

aimler — Tue, 19 Aug 2025 10:17:56 +0900

ETL ( Extract → Transform → Load )
- 전통적 방식
- 데이터를 원본에서 추출(Extract) → 중간 처리 서버에서 변환(Transform) → 최종적으로 데이터 웨어하우스에 적재(Load)
- 데이터 웨어하우스의 연산 능력이 부족하던 시절에 주로 사용됨
- [Source] → (Extract) → [ETL 서버에서 Transform] → (Load) → [Data Warehouse]
ELT ( Extract → Load → Transform )
- 현대적 방식 (dbt가 여기에 해당)
- 데이터를 원본에서 추출(Extract) → 그대로 데이터 웨어하우스에 적재(Load) → 웨어하우스 내부에서 SQL 기반 변환(Transform) 수행
- Snowflake, BigQuery, Redshift, Databricks 등 강력한 클라우드 DWH가 등장하면서 표준이 됨
- [Source] → (Extract + Load, Ingestion) → [Data Warehouse] → (Transform, dbt) → [Analytics-ready Data]
요약

구분	ETL	ELT (dbt 활용)
Transform 위치	ETL 서버(외부 처리 엔진)	데이터 웨어하우스 내부
데이터 적재 순서	변환 후 Load	Load 후 변환
도구 예시	Informatica, Talend, Pentaho	dbt, SQL, BigQuery/Snowflake/Redshift 내장 기능
장점	- 웨어하우스 부담 ↓- 보안·정책 제약 환경에서 유리	- 웨어하우스의 강력한 성능 활용- 단순 구조 (원시데이터와 정제데이터 모두 보관)- SQL만으로 개발 가능
단점	- 변환 서버 운영 필요- 확장성 낮음	- 웨어하우스 비용 증가 가능- 웨어하우스 의존도 ↑
사용 사례	과거 온프레미스 DWH 환경	최신 클라우드 DWH + dbt 파이프라인

Ingestion vs Transformation 비교

aimler — Tue, 19 Aug 2025 10:12:16 +0900

구분	Ingestion	Transformation (dbt)
의미	원천(Source) 시스템에서 데이터를 수집하여 웨어하우스/데이터레이크에 옮겨 적재하는 과정	웨어하우스 내부에 적재된 원시(raw) 데이터를 정제·모델링·가공하는 과정
ETL/ELT 단계	E(Extract) + L(Load)	T(Transform)
주요 도구	Fivetran, Stitch, Airbyte, Spark, Python 스크립트 등	dbt Core / dbt Cloud
출력 결과	웨어하우스의 Landing / Raw Layer (원시 데이터)	웨어하우스의 Staging / Warehouse / Mart Layer (분석·비즈니스 친화적 데이터)
기술적 초점	- 데이터 이동 자동화- API, DB 커넥터, 스트리밍 등 지원- 스키마나 포맷 변환 최소화	- SQL 기반 모델링- 데이터 품질 검증(Test)- 의존성 관리(DAG)- 문서화 자동화
사용자	데이터 엔지니어 중심	데이터 분석가 + 애널리틱스 엔지니어
예시	“Facebook Ads 데이터를 Snowflake로 매일 적재”	“Snowflake에 쌓인 Ads 데이터를 정제해 마케팅 ROI 리포트용 테이블 생성”

주가 이동평균 구하는 Query (MySQL, Mariadb)

aimler — Thu, 7 Aug 2025 14:37:52 +0900

주가 데이터 와 이동평균을 Grafana의 차트에 표시해주기위환 MySQL 쿼리 입니다.

일 배치로 이동평균을 계산해 놓을수 도 있지만 좁은 기간의 데이터 조회가 빈번할 때는

쿼리에서 이동평균을 계산해도 괜찮을 것 같아 쿼리를 제작하였습니다.

이동평균을 주가 뿐만 아니라 DAU등에 접목해도 좋을 것 같습니다.

✅ 데이터 구조

event_date	symbol_code	tradePrice
2025-04-18	35420	187,500
2025-04-21	35420	187,500
2025-04-22	35420	193,700
2025-04-23	35420	192,900
2025-04-24	35420	191,500
2025-04-25	35420	193,500
2025-04-28	35420	195,500
2025-04-29	35420	196,500
2025-04-30	35420	200,500
2025-05-02	35420	197,400

✅ 쿼리

set @symbol_code = '035420';    -- 종목 코드
set @interval_day = 100;        -- 현재일 기준 조회 기간
with sub as (
    select event_date, tradePrice, day_5_moving_avg, day_10_moving_avg, day_20_moving_avg, day_60_moving_avg
    from (
        SELECT event_date, symbol_code, tradePrice
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 4 PRECEDING AND CURRENT ROW), 2) AS day_5_moving_avg  -- 5일 이동 평균
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 9 PRECEDING AND CURRENT ROW), 2) AS day_10_moving_avg  -- 10일 이동 평균
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 19 PRECEDING AND CURRENT ROW), 2) AS day_20_moving_avg  -- 20일 이동 평균
            , ROUND(AVG(tradePrice)OVER (ORDER BY event_date ROWS BETWEEN 59 PRECEDING AND CURRENT ROW), 2) AS day_60_moving_avg  -- 60일 이동 평균
        FROM tbl_stock_list_kor
        WHERE event_date >= date_add(current_date, interval (abs(@interval_day) + 100) * -1 day)
            and event_date <= current_date
            and symbol_code = @symbol_code
    ) as ta
    where event_date >= date_add(current_date, interval abs(@interval_day) * -1 day) and event_date <= current_date
)
select cast(ta.event_date as char(10)) as event_date
    , (case tb.rno when 1 then '주가'
                when 2 then '5일선'
                when 3 then '10일선'
                when 4 then '20일선'
                when 5 then '60일선'
                end) as legend
, (case tb.rno when 1 then ta.tradePrice
                when 2 then ta.day_5_moving_avg
                when 3 then ta.day_10_moving_avg
                when 4 then ta.day_20_moving_avg
                when 5 then ta.day_60_moving_avg
                end) as price
from sub as ta
cross join (select 1 rno union select 2 union select 3 union select 4 union select 5) as tb
order by event_date asc, legend asc;

✅ 쿼리 실행 결과

event_date	legend	price
2025-04-29	10일선	190,660
2025-04-29	20일선	189,630
2025-04-29	5일선	193,980
2025-04-29	60일선	206,630
2025-04-29	주가	196,500
2025-04-30	10일선	192,270
2025-04-30	20일선	189,875
2025-04-30	5일선	195,500
2025-04-30	60일선	206,330
2025-04-30	주가	200,500

✅ Chart

DAU 데이터의 z-score 계산 Query

aimler — Wed, 30 Jul 2025 09:15:56 +0900

> DAU 데이터 구조

event_date	dau
2025-07-01	12,000
2025-07-02	13,000
2025-07-03	15,000
2025-07-04	13,500
2025-07-05	16,000
2025-07-06	15,000
2025-07-07	19,000

> DAU 및 Z-Score 조회 쿼리

SELECT
    event_date,
    dau,
    ROUND((dau - stats.avg_dau) / stats.std_dau, 4) AS dau_zscore
FROM
    tbl_dau as ta,
    (
        SELECT
            AVG(dau) AS avg_dau,
            STDDEV(dau) AS std_dau
        FROM tbl_dau
        where event_date >= '2025-07-01'
            and event_date < '2025-07-11'
    ) AS stats
where ta.event_date >= '2025-07-01'
    and ta.event_date < '2025-07-11'
ORDER BY event_date;

> 조회 결과

event_date	dau	dau_zscore
2025-07-01	12,000	-1.3044
2025-07-02	13,000	-0.8361
2025-07-03	15,000	0.1003
2025-07-04	13,500	-0.602
2025-07-05	16,000	0.5686
2025-07-06	15,000	0.1003
2025-07-07	19,000	1.9733

머신러닝 모델 유형별 대표적인 평가 지표

aimler — Fri, 25 Jul 2025 17:30:13 +0900

> 분류( Classification ) 모델 평가 지표

지표명	설명	특징/용도
Accuracy (정확도)	전체 중 맞게 예측한 비율	클래스 균형이 잘 맞을 때 적합
Precision (정밀도)	양성 예측 중 실제 양성 비율	FP(거짓양성) 줄일 때 중요
Recall (재현율)	실제 양성 중 맞게 예측한 비율	FN(거짓음성) 줄일 때 중요
F1 Score	정밀도와 재현율의 조화평균	정밀도와 재현율 균형 필요할 때
ROC-AUC	거짓양성비율 대비 참양성비율 곡선 아래 면적	임계값 무관, 클래스 불균형 문제에 강함
PR-AUC (P-R 곡선 아래 면적)	정밀도와 재현율 곡선 아래 면적	불균형 데이터에서 성능 평가에 더 적합
Confusion Matrix	TP, FP, TN, FN 행렬 형태로 예측 결과 요약	다양한 지표 계산의 기본 자료
Log Loss (Cross-Entropy)	확률 예측과 실제값 간 차이	확률 기반 분류 모델 성능 평가
MCC (Matthews Correlation Coefficient)	불균형 데이터에서 균형 잡힌 평가 지표	데이터 불균형 심할 때 권장

> 회귀 (Regression) 모델 평가 지표

지표명	설명	특징/용도
MSE (Mean Squared Error)	오차 제곱의 평균	큰 오차에 민감
RMSE (Root MSE)	MSE의 제곱근	단위가 원래 값과 같아 해석 용이
MAE (Mean Absolute Error)	절대 오차 평균	이상치에 덜 민감
MAPE (Mean Absolute Percentage Error)	절대 오차를 실제 값으로 나눈 비율의 평균 (백분율)	오차를 %로 직관적으로 표현, 0에 가까운 값 주의
R² (결정계수)	모델이 데이터 분산을 얼마나 설명하는지 비율	1에 가까울수록 좋은 설명력

> 클러스터링 (Clustering) 평가 지표

지표명	설명	특징/용도
Silhouette Score	군집 간 거리와 군집 내 거리 비율	1에 가까울수록 군집 품질 좋음
Davies-Bouldin Index	군집 간 거리 대비 군집 내 거리 비율	값이 작을수록 군집 품질 좋음
Calinski-Harabasz Index	군집 간 분산 대비 군집 내 분산 비율	값이 클수록 군집 품질 좋음

Grafana Business Chart 누적형 그래프 그리기

aimler — Tue, 1 Jul 2025 13:09:43 +0900

Grafana에서 Business Chart를 사용해서 누적형 그래프를 그리는 방법을 설명하겠습니다.

• 데이터 구조

legend	xvalue	yvalue
A	2074-01	138,938
B	2074-01	31,065
C	2074-01	9,509
D	2074-01	22,073
A	2074-02	121,677
B	2074-02	31,899
C	2074-02	12,903
D	2074-02	21,503

• 그래프

• Script 코드

const dataMap = {}; 							// 시즌별 데이터 저장용
const xLabelsSet = new Set(); 	// x축 레벨 값들
let minYValue = Infinity;      			// y축 최소값 계산용

context.panel.data.series.forEach((series) => {
  const legendField = series.fields.find(f => f.name.toLowerCase().includes("legend"));		// 범례
  const xvalueField = series.fields.find(f => f.name.toLowerCase().includes("xvalue"));			// x축에 표시할 값
  const yvalueField = series.fields.find(f => f.name.toLowerCase().includes("yvalue"));			// y축에 표시할 값
  if (!legendField || !xvalueField || !yvalueField) return;

  const legends = legendField.values;		// 범례 배열
  const xvalues = xvalueField.values;		// x축 값 배열
  const values = yvalueField.values;			// y축 값 배열

  for (let i = 0; i < legends.length; i++) {
    const legend = legends.get(i);
    const xvalue = xvalues.get(i);
    const yvalue = values.get(i);
    xLabelsSet.add(xvalue);

    if (!dataMap[legend]) {
      dataMap[legend] = {};
    }
    dataMap[legend][xvalue] = yvalue;

    // 최소값 갱신
    if (typeof yvalue === 'number' && yvalue < minYValue) {
      minYValue = yvalue;
    }
  }
});

// x축 정렬된 레벨 값들 (문자열 기준 정렬)
const xLabels = Array.from(xLabelsSet).sort((a, b) => a - b);

// 시리즈 생성
const series = Object.keys(dataMap).map(legend => {
  const xValueMap = dataMap[legend];
  const displayData = xLabels.map(xvalue => xValueMap[xvalue] ?? null);
  // 최고값 찾기
  let maxIndex = -1;
  let maxValue = -Infinity;
  displayData.forEach((v, i) => {
    if (typeof v === 'number' && v > maxValue) {
      maxValue = v;
      maxIndex = i;
    }
  });

  return {
    name: legend,
    type: "line",
    stack: "total",
    data: displayData,
    symbolSize: 4,    // 점의 크기
    areaStyle: {
      opacity: 0.3    // 투명도 조절 (0 ~ 1 사이 값)
    },
  };
});

return {
  grid: {
    bottom: "4.5%",
    containLabel: true,
    left: "3%",
    right: "4%"
  },
  tooltip: {
    trigger: "item",
    axisPointer: {
      type: 'cross',
    },
    formatter: function (params) {
      // 숫자 포맷: 천단위 구분
      const value = typeof params.data === 'number'
        ? params.data.toLocaleString('ko-KR')
        : params.data;
      return `
        ${params.marker}
        <strong style="color:${params.color}">${params.seriesName}</strong>: ${value}
      `;
    }
  },
  legend: {
    name: '시즌',
    data: Object.keys(dataMap)
  },
  xAxis: {  // x축 설정
    name: '',           // 축 이름 텍스트.
    nameLocation: "middle", // "start", "middle", "end" 가능. 이름의 위치 지정.
    nameGap: 25,            // 축 이름과 축 간의 거리(px)
    nameTextStyle: {        // 폰트 크기, 두께 등 스타일 설정
      fontSize: 14,
      fontWeight: 'bold'
    },
    boundaryGap: false,
    type: "category",
    data: xLabels, 
    axisLabel: {
      margin: 25,       // 레이블과 축 간 거리
      fontSize: 13      // ← 글씨 크기 설정 (예: 12px)
    }
  },
  yAxis: {  // y축 설정
    name: '',
    nameTextStyle: {
      fontSize: 14,
      fontWeight: 'bold'
    },
    type: "value",
    min: (minYValue * 0.85).toFixed(0)
  },
  series
};

Grafana Business Charts Tooltip 가이드

aimler — Fri, 30 May 2025 15:22:57 +0900

Grafana에서 Business Charts를 사용할 때 Tooltip에 표시되는 내용을 정렬하는 방법을 설명드리겠습니다.

• 적용 전 / 후의 모습입니다.

• tooltip 옵션의 코드를 아래와 같이 수정합니다.

tooltip: {
  trigger: "axis",
  formatter: function (params) {
    // 수치를 천 단위로 변환하는 함수
    const formatNumber = num => {
      if (num == null || isNaN(num)) return '-';
      return num.toLocaleString();  // 또는: String(num).replace(/\B(?=(\d{3})+(?!\d))/g, ",")
    };

    const sortedParams = params.slice().sort((a, b) => {
      const aVal = a.data != null ? a.data : -Infinity;
      const bVal = b.data != null ? b.data : -Infinity;
      return bVal - aVal;
    });

    let text = `${params[0].axisValue}<br/>`;
    sortedParams.forEach(param => {
      text += `
        <span style="display:inline-block;margin-right:5px;border-radius:10px;width:9px;height:9px;background-color:${param.color};"></span>
        ${param.seriesName}: ${formatNumber(param.data)}<br/>
      `;
    });
    return text;
  }
}

Grafana Business Charts 사용 가이드

aimler — Fri, 30 May 2025 13:18:50 +0900

Grafana에서 서드파티 차트중 Business Charts를 사용하는 방법을 알려드리겠습니다.

0. legend / xvalue / yvalue 컬럼으로 이루어진 데이터를 준비합니다.

1. Business Charts 를 선택 > Editor Mode를 Visual로 선택합니다.

2. 아래 JavaScript 코드를 Visual Editor 탭의 Function에 붙여넣어 줍니다.

코드에 대한 설명은 주석을 참고하시거나 ChatGPT에 코드를 붙여넣은 후 프로프트로 코드 수정을 질문하시면 꽤 정확한 답변을 얻으실 수 있습니다.

const dataMap = {}; 					  // 전체 데이터
const xLabelsSet = new Set(); 	// X축 라벨값 집합

// 데이터 집합을 생성합니다.
context.panel.data.series.forEach((series) => {
  const legendField = series.fields.find(f => f.name.toLowerCase().includes("legend"));		// 범례
  const xValueField = series.fields.find(f => f.name.toLowerCase().includes("xvalue"));		//  X 축
  const yValueField = series.fields.find(f => f.name.toLowerCase().includes("yvalue"));		// Y 축
  if (!legendField || !xValueField || !yValueField) return;

  const legends = legendField.values;
  const xValues = xValueField.values;
  const yValues = yValueField.values;

  for (let i = 0; i < legends.length; i++) {
    const legend = legends.get(i);
    const xValue = xValues.get(i);
    const yValue = yValues.get(i);
    xLabelsSet.add(xValue);
    if (!dataMap[legend]) {
      dataMap[legend] = {};
    }
    dataMap[legend][xValue] = yValue;
  }
});

// X축에 표시할 Unique 라벨 배열
const xLabels = Array.from(xLabelsSet).sort((a, b) => a - b);
// 시리즈 생성
const series = Object.keys(dataMap).map(legend => {
  const xValueMap = dataMap[legend];
  const yValueMap = xLabels.map(xValue => xValueMap[xValue] ?? null);
  return {
    name: legend,     // 범례에 속한 항목 이름
    type: "line",     // 차트 타입(bar, line)
    stack: "",
    data: yValueMap   // Y Value 데이터 배열
  };
});

return {
  grid: {
    top: "30%",
    bottom: "5%",  // 그래프 하단의 여백을 설정하는 효과가 있습니다.
    containLabel: true,
    left: "3%",
    right: "4%"
  },
  tooltip: {
    trigger: "axis"
  },
  legend: { // 범례 설정
    type: 'plain', // plain, scroll
    name: '모델',
    data: Object.keys(dataMap),
    orient: 'horizontal',      // 수평 정렬
    top: 'top',
    left: 'center',
    itemGap: 10,               // 범례 항목 간 간격
    padding: [10, 20],         // 범례 영역 안쪽 여백
    width: '80%',              // 너비 제한을 주면 줄바꿈 발생 가능
    textStyle: {
      fontSize: 14
    }
  },
  xAxis: {  // x축 설정
    name: '',           // 축 이름 텍스트.
    nameLocation: "middle", // "start", "middle", "end" 가능. 이름의 위치 지정.
    nameGap: 30,            // 축 이름과 축 간의 거리(px)
    nameTextStyle: {        // 폰트 크기, 두께 등 스타일 설정
      fontSize: 20,
      fontWeight: 'bold'
    },
    boundaryGap: true,
    type: "category",
    data: xLabels,
    axisLabel: {
      fontSize: 14,
      rotate: 60,  // 라벨을 45도 기울임
      interval: 0 // 모든 항목 출력 (스크롤 지원에 필수)
    }
  },
  yAxis: {  // y축 설정
    name: '판매량',
    nameTextStyle: {
      fontSize: 14,
      fontWeight: 'bold'
    },
    type: "value",
    interval: 100000  // 10 단위 간격 설정
  },
  series,
  dataZoom: [
    {
      type: 'slider',
      show: true,
      xAxisIndex: 0,
      start: 0,
      end: xLabels.length > 20 ? 50 : 100
    }
  ],
  graphic: [
    {
      type: 'text',
      left: 'left',
      bottom: '20',   // 'bottom'은 grid 바깥 기준이므로, 그래프 아래 적당한 픽셀 위치로 설정
      left: '70',   // 좌측 여백을 설정합니다.
    }
  ]
};

3. 그래프의 출력 결과는 아래와 같습니다.