❯ docker compose -f ~/.financebench/repo/compose.minimal.yml logs api 2>&1 | grep -A 15 "Pipeline boot" | head -15

api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING [Pipeline boot] run_id=run_20260528_165155  event_log=/app/logs/run_20260528_165155.jsonl
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING ==============================================================================
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING git:         ? (clean)
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING reranker:    {'error': "ModuleNotFoundError: No module named 'peft'"}
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING grader:      {'class': 'ChatGroq', 'model': 'llama-3.3-70b-versatile', 'base_url': '(provider-default)'}
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING generator:   claude-sonnet-4-6  hallu: claude-sonnet-4-6
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING embedding:   openai/text-embedding-3-large (dim=3072)
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING qdrant:      {'endpoint': 'qdrant:6333', 'collection': 'financial_docs', 'error': 'UnexpectedResponse: Unexpected Response: 404 (Not Found)\nRaw response content:\nb\'{"status":{"error":"Not found: Collection `financial_docs` doesn\\\'t exist!"},"time":0.000422084}\''}
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING redis:       {'endpoint': 'redis:6379', 'connected': True, 'n_keys': 0}
api-1  | 2026-05-28 16:51:55,627 src.services.event_log WARNING flags:       USE_LLAMA_GRADER=False  USE_GROQ_FAST_PATH=True  RETRIEVAL_TOP_K=50  MULTI_HYDE=False
api-1  | 2026-05-28 16:51:55,628 src.services.event_log WARNING ==============================================================================
api-1  | 2026-05-28 16:51:55,782 alembic.runtime.plugins INFO setup plugin alembic.autogenerate.schemas
api-1  | 2026-05-28 16:51:55,782 alembic.runtime.plugins INFO setup plugin alembic.autogenerate.tables
api-1  | 2026-05-28 16:51:55,782 alembic.runtime.plugins INFO setup plugin alembic.autogenerate.types
api-1  | 2026-05-28 16:51:55,782 alembic.runtime.plugins INFO setup plugin alembic.autogenerate.constraints
❯ curl -s http://localhost:8000/v1/warm | python3 -m json.tool
Expecting value: line 1 column 1 (char 0)



❯ curl -s http://localhost:8000/v1/warm | python3 -m json.tool
Expecting value: line 1 column 1 (char 0)
❯ financebench login -u analyst

Password:
╭────────────────────────────── Traceback (most recent call last) ──────────────────────────────╮
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_transports/default.py:101  │
│ in map_httpcore_exceptions                                                                    │
│                                                                                               │
│    98 │   if len(HTTPCORE_EXC_MAP) == 0:                                                      │
│    99 │   │   HTTPCORE_EXC_MAP = _load_httpcore_exceptions()                                  │
│   100 │   try:                                                                                │
│ ❱ 101 │   │   yield                                                                           │
│   102 │   except Exception as exc:                                                            │
│   103 │   │   mapped_exc = None                                                               │
│   104                                                                                         │
│                                                                                               │
│ ╭──────────────────── locals ─────────────────────╮                                           │
│ │ message = '[Errno 54] Connection reset by peer' │                                           │
│ ╰─────────────────────────────────────────────────╯                                           │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_transports/default.py:250  │
│ in handle_request                                                                             │
│                                                                                               │
│   247 │   │   │   extensions=request.extensions,                                              │
│   248 │   │   )                                                                               │
│   249 │   │   with map_httpcore_exceptions():                                                 │
│ ❱ 250 │   │   │   resp = self._pool.handle_request(req)                                       │
│   251 │   │                                                                                   │
│   252 │   │   assert isinstance(resp.stream, typing.Iterable)                                 │
│   253                                                                                         │
│                                                                                               │
│ ╭───────────────────────────────────────── locals ──────────────────────────────────────────╮ │
│ │ httpcore = <module 'httpcore' from                                                        │ │
│ │            '/Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/__init_… │ │
│ │      req = <Request [b'POST']>                                                            │ │
│ │  request = <Request('POST', 'http://localhost:8000/v1/auth/login')>                       │ │
│ │     self = <httpx.HTTPTransport object at 0x1030870b0>                                    │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/connection_pool.py │
│ :256 in handle_request                                                                        │
│                                                                                               │
│   253 │   │   │   │   closing = self._assign_requests_to_connections()                        │
│   254 │   │   │                                                                               │
│   255 │   │   │   self._close_connections(closing)                                            │
│ ❱ 256 │   │   │   raise exc from None                                                         │
│   257 │   │                                                                                   │
│   258 │   │   # Return the response. Note that in this case we still have to manage           │
│   259 │   │   # the point at which the response is closed.                                    │
│                                                                                               │
│ ╭───────────────────────────────────────── locals ──────────────────────────────────────────╮ │
│ │      closing = []                                                                         │ │
│ │   connection = <HTTPConnection ['http://localhost:8000', HTTP/1.1, CLOSED, Request Count: │ │
│ │                1]>                                                                        │ │
│ │ pool_request = <httpcore._sync.connection_pool.PoolRequest object at 0x1036b75c0>         │ │
│ │      request = <Request [b'POST']>                                                        │ │
│ │       scheme = 'http'                                                                     │ │
│ │         self = <ConnectionPool [Requests: 0 active, 0 queued | Connections: 0 active, 0   │ │
│ │                idle]>                                                                     │ │
│ │      timeout = 180.0                                                                      │ │
│ │     timeouts = {'connect': 180.0, 'read': 180.0, 'write': 180.0, 'pool': 180.0}           │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/connection_pool.py │
│ :236 in handle_request                                                                        │
│                                                                                               │
│   233 │   │   │   │                                                                           │
│   234 │   │   │   │   try:                                                                    │
│   235 │   │   │   │   │   # Send the request on the assigned connection.                      │
│ ❱ 236 │   │   │   │   │   response = connection.handle_request(                               │
│   237 │   │   │   │   │   │   pool_request.request                                            │
│   238 │   │   │   │   │   )                                                                   │
│   239 │   │   │   │   except ConnectionNotAvailable:                                          │
│                                                                                               │
│ ╭───────────────────────────────────────── locals ──────────────────────────────────────────╮ │
│ │      closing = []                                                                         │ │
│ │   connection = <HTTPConnection ['http://localhost:8000', HTTP/1.1, CLOSED, Request Count: │ │
│ │                1]>                                                                        │ │
│ │ pool_request = <httpcore._sync.connection_pool.PoolRequest object at 0x1036b75c0>         │ │
│ │      request = <Request [b'POST']>                                                        │ │
│ │       scheme = 'http'                                                                     │ │
│ │         self = <ConnectionPool [Requests: 0 active, 0 queued | Connections: 0 active, 0   │ │
│ │                idle]>                                                                     │ │
│ │      timeout = 180.0                                                                      │ │
│ │     timeouts = {'connect': 180.0, 'read': 180.0, 'write': 180.0, 'pool': 180.0}           │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/connection.py:103  │
│ in handle_request                                                                             │
│                                                                                               │
│   100 │   │   │   self._connect_failed = True                                                 │
│   101 │   │   │   raise exc                                                                   │
│   102 │   │                                                                                   │
│ ❱ 103 │   │   return self._connection.handle_request(request)                                 │
│   104 │                                                                                       │
│   105 │   def _connect(self, request: Request) -> NetworkStream:                              │
│   106 │   │   timeouts = request.extensions.get("timeout", {})                                │
│                                                                                               │
│ ╭───────────────────────────────────────── locals ──────────────────────────────────────────╮ │
│ │ http2_negotiated = False                                                                  │ │
│ │          request = <Request [b'POST']>                                                    │ │
│ │             self = <HTTPConnection ['http://localhost:8000', HTTP/1.1, CLOSED, Request    │ │
│ │                    Count: 1]>                                                             │ │
│ │       ssl_object = None                                                                   │ │
│ │           stream = <httpcore._backends.sync.SyncStream object at 0x1036b7740>             │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/http11.py:136 in   │
│ handle_request                                                                                │
│                                                                                               │
│   133 │   │   │   with ShieldCancellation():                                                  │
│   134 │   │   │   │   with Trace("response_closed", logger, request) as trace:                │
│   135 │   │   │   │   │   self._response_closed()                                             │
│ ❱ 136 │   │   │   raise exc                                                                   │
│   137 │                                                                                       │
│   138 │   # Sending the request...                                                            │
│   139                                                                                         │
│                                                                                               │
│ ╭───────────────────────────────────── locals ─────────────────────────────────────╮          │
│ │  kwargs = {'request': <Request [b'POST']>}                                       │          │
│ │ request = <Request [b'POST']>                                                    │          │
│ │    self = <HTTP11Connection ['http://localhost:8000', CLOSED, Request Count: 1]> │          │
│ │   trace = <httpcore._trace.Trace object at 0x1036b5b80>                          │          │
│ ╰──────────────────────────────────────────────────────────────────────────────────╯          │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/http11.py:106 in   │
│ handle_request                                                                                │
│                                                                                               │
│   103 │   │   │   │   │   reason_phrase,                                                      │
│   104 │   │   │   │   │   headers,                                                            │
│   105 │   │   │   │   │   trailing_data,                                                      │
│ ❱ 106 │   │   │   │   ) = self._receive_response_headers(**kwargs)                            │
│   107 │   │   │   │   trace.return_value = (                                                  │
│   108 │   │   │   │   │   http_version,                                                       │
│   109 │   │   │   │   │   status,                                                             │
│                                                                                               │
│ ╭───────────────────────────────────── locals ─────────────────────────────────────╮          │
│ │  kwargs = {'request': <Request [b'POST']>}                                       │          │
│ │ request = <Request [b'POST']>                                                    │          │
│ │    self = <HTTP11Connection ['http://localhost:8000', CLOSED, Request Count: 1]> │          │
│ │   trace = <httpcore._trace.Trace object at 0x1036b5b80>                          │          │
│ ╰──────────────────────────────────────────────────────────────────────────────────╯          │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/http11.py:177 in   │
│ _receive_response_headers                                                                     │
│                                                                                               │
│   174 │   │   timeout = timeouts.get("read", None)                                            │
│   175 │   │                                                                                   │
│   176 │   │   while True:                                                                     │
│ ❱ 177 │   │   │   event = self._receive_event(timeout=timeout)                                │
│   178 │   │   │   if isinstance(event, h11.Response):                                         │
│   179 │   │   │   │   break                                                                   │
│   180 │   │   │   if (                                                                        │
│                                                                                               │
│ ╭───────────────────────────────────── locals ──────────────────────────────────────╮         │
│ │  request = <Request [b'POST']>                                                    │         │
│ │     self = <HTTP11Connection ['http://localhost:8000', CLOSED, Request Count: 1]> │         │
│ │  timeout = 180.0                                                                  │         │
│ │ timeouts = {'connect': 180.0, 'read': 180.0, 'write': 180.0, 'pool': 180.0}       │         │
│ ╰───────────────────────────────────────────────────────────────────────────────────╯         │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_sync/http11.py:217 in   │
│ _receive_event                                                                                │
│                                                                                               │
│   214 │   │   │   │   event = self._h11_state.next_event()                                    │
│   215 │   │   │                                                                               │
│   216 │   │   │   if event is h11.NEED_DATA:                                                  │
│ ❱ 217 │   │   │   │   data = self._network_stream.read(                                       │
│   218 │   │   │   │   │   self.READ_NUM_BYTES, timeout=timeout                                │
│   219 │   │   │   │   )                                                                       │
│   220                                                                                         │
│                                                                                               │
│ ╭───────────────────────────────────── locals ─────────────────────────────────────╮          │
│ │    self = <HTTP11Connection ['http://localhost:8000', CLOSED, Request Count: 1]> │          │
│ │ timeout = 180.0                                                                  │          │
│ ╰──────────────────────────────────────────────────────────────────────────────────╯          │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_backends/sync.py:126 in │
│ read                                                                                          │
│                                                                                               │
│   123 │                                                                                       │
│   124 │   def read(self, max_bytes: int, timeout: float | None = None) -> bytes:              │
│   125 │   │   exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}   │
│ ❱ 126 │   │   with map_exceptions(exc_map):                                                   │
│   127 │   │   │   self._sock.settimeout(timeout)                                              │
│   128 │   │   │   return self._sock.recv(max_bytes)                                           │
│   129                                                                                         │
│                                                                                               │
│ ╭──────────────────────────────── locals ─────────────────────────────────╮                   │
│ │   exc_map = {                                                           │                   │
│ │             │   <class 'TimeoutError'>: <class 'httpcore.ReadTimeout'>, │                   │
│ │             │   <class 'OSError'>: <class 'httpcore.ReadError'>         │                   │
│ │             }                                                           │                   │
│ │ max_bytes = 65536                                                       │                   │
│ │      self = <httpcore._backends.sync.SyncStream object at 0x1036b7740>  │                   │
│ │   timeout = 180.0                                                       │                   │
│ ╰─────────────────────────────────────────────────────────────────────────╯                   │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/contextlib.py:158 in __exit__                   │
│                                                                                               │
│   155 │   │   │   │   # tell if we get the same exception back                                │
│   156 │   │   │   │   value = typ()                                                           │
│   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                 │
│                                                                                               │
│ ╭──────────────────────────────── locals ─────────────────────────────────╮                   │
│ │      self = <contextlib._GeneratorContextManager object at 0x103675ee0> │                   │
│ │ traceback = <traceback object at 0x1036cb0c0>                           │                   │
│ │     value = ConnectionResetError(54, 'Connection reset by peer')        │                   │
│ ╰─────────────────────────────────────────────────────────────────────────╯                   │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/_exceptions.py:14 in     │
│ map_exceptions                                                                                │
│                                                                                               │
│   11 │   except Exception as exc:  # noqa: PIE786                                             │
│   12 │   │   for from_exc, to_exc in map.items():                                             │
│   13 │   │   │   if isinstance(exc, from_exc):                                                │
│ ❱ 14 │   │   │   │   raise to_exc(exc) from exc                                               │
│   15 │   │   raise  # pragma: nocover                                                         │
│   16                                                                                          │
│   17                                                                                          │
│                                                                                               │
│ ╭───────────────────────────── locals ──────────────────────────────╮                         │
│ │ map = {                                                           │                         │
│ │       │   <class 'TimeoutError'>: <class 'httpcore.ReadTimeout'>, │                         │
│ │       │   <class 'OSError'>: <class 'httpcore.ReadError'>         │                         │
│ │       }                                                           │                         │
│ ╰───────────────────────────────────────────────────────────────────╯                         │
╰───────────────────────────────────────────────────────────────────────────────────────────────╯
ReadError: [Errno 54] Connection reset by peer

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

╭────────────────────────────── Traceback (most recent call last) ──────────────────────────────╮
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/cli/commands/login.py:27 in login │
│                                                                                               │
│   24 │                                                                                        │
│   25 │   client = APIClient(base_url=base_url, token=None)                                    │
│   26 │   try:                                                                                 │
│ ❱ 27 │   │   resp = client.post(                                                              │
│   28 │   │   │   "/v1/auth/login",                                                            │
│   29 │   │   │   {"username": user, "password": password},                                    │
│   30 │   │   │   auth_required=False,                                                         │
│                                                                                               │
│ ╭────────────────────────── locals ───────────────────────────╮                               │
│ │ base_url = 'http://localhost:8000'                          │                               │
│ │   client = <cli.api_client.APIClient object at 0x10320ef00> │                               │
│ │ password = 'analyst123'                                     │                               │
│ │     user = 'analyst'                                        │                               │
│ ╰─────────────────────────────────────────────────────────────╯                               │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/cli/api_client.py:54 in post      │
│                                                                                               │
│   51 │   │   │   raise APIError(r.status_code, detail if isinstance(detail, str) else str(det │
│   52 │                                                                                        │
│   53 │   def post(self, path: str, json_body: dict, auth_required: bool = True) -> dict:      │
│ ❱ 54 │   │   r = self._client.post(path, json=json_body, headers=self._headers(auth_required) │
│   55 │   │   self._raise_for(r)                                                               │
│   56 │   │   return r.json()                                                                  │
│   57                                                                                          │
│                                                                                               │
│ ╭───────────────────────────── locals ──────────────────────────────╮                         │
│ │ auth_required = False                                             │                         │
│ │     json_body = {'username': 'analyst', 'password': 'analyst123'} │                         │
│ │          path = '/v1/auth/login'                                  │                         │
│ │          self = <cli.api_client.APIClient object at 0x10320ef00>  │                         │
│ ╰───────────────────────────────────────────────────────────────────╯                         │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_client.py:1144 in post     │
│                                                                                               │
│   1141 │   │                                                                                  │
│   1142 │   │   **Parameters**: See `httpx.request`.                                           │
│   1143 │   │   """                                                                            │
│ ❱ 1144 │   │   return self.request(                                                           │
│   1145 │   │   │   "POST",                                                                    │
│   1146 │   │   │   url,                                                                       │
│   1147 │   │   │   content=content,                                                           │
│                                                                                               │
│ ╭───────────────────────────────── locals ──────────────────────────────────╮                 │
│ │             auth = <httpx._client.UseClientDefault object at 0x1022eba10> │                 │
│ │          content = None                                                   │                 │
│ │          cookies = None                                                   │                 │
│ │             data = None                                                   │                 │
│ │       extensions = None                                                   │                 │
│ │            files = None                                                   │                 │
│ │ follow_redirects = <httpx._client.UseClientDefault object at 0x1022eba10> │                 │
│ │          headers = {'Content-Type': 'application/json'}                   │                 │
│ │             json = {'username': 'analyst', 'password': 'analyst123'}      │                 │
│ │           params = None                                                   │                 │
│ │             self = <httpx.Client object at 0x103401d60>                   │                 │
│ │          timeout = <httpx._client.UseClientDefault object at 0x1022eba10> │                 │
│ │              url = '/v1/auth/login'                                       │                 │
│ ╰───────────────────────────────────────────────────────────────────────────╯                 │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_client.py:825 in request   │
│                                                                                               │
│    822 │   │   │   timeout=timeout,                                                           │
│    823 │   │   │   extensions=extensions,                                                     │
│    824 │   │   )                                                                              │
│ ❱  825 │   │   return self.send(request, auth=auth, follow_redirects=follow_redirects)        │
│    826 │                                                                                      │
│    827 │   @contextmanager                                                                    │
│    828 │   def stream(                                                                        │
│                                                                                               │
│ ╭────────────────────────────────── locals ───────────────────────────────────╮               │
│ │             auth = <httpx._client.UseClientDefault object at 0x1022eba10>   │               │
│ │          content = None                                                     │               │
│ │          cookies = None                                                     │               │
│ │             data = None                                                     │               │
│ │       extensions = None                                                     │               │
│ │            files = None                                                     │               │
│ │ follow_redirects = <httpx._client.UseClientDefault object at 0x1022eba10>   │               │
│ │          headers = {'Content-Type': 'application/json'}                     │               │
│ │             json = {'username': 'analyst', 'password': 'analyst123'}        │               │
│ │           method = 'POST'                                                   │               │
│ │           params = None                                                     │               │
│ │          request = <Request('POST', 'http://localhost:8000/v1/auth/login')> │               │
│ │             self = <httpx.Client object at 0x103401d60>                     │               │
│ │          timeout = <httpx._client.UseClientDefault object at 0x1022eba10>   │               │
│ │              url = '/v1/auth/login'                                         │               │
│ ╰─────────────────────────────────────────────────────────────────────────────╯               │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_client.py:914 in send      │
│                                                                                               │
│    911 │   │                                                                                  │
│    912 │   │   auth = self._build_request_auth(request, auth)                                 │
│    913 │   │                                                                                  │
│ ❱  914 │   │   response = self._send_handling_auth(                                           │
│    915 │   │   │   request,                                                                   │
│    916 │   │   │   auth=auth,                                                                 │
│    917 │   │   │   follow_redirects=follow_redirects,                                         │
│                                                                                               │
│ ╭────────────────────────────────── locals ───────────────────────────────────╮               │
│ │             auth = <httpx.Auth object at 0x103231490>                       │               │
│ │ follow_redirects = False                                                    │               │
│ │          request = <Request('POST', 'http://localhost:8000/v1/auth/login')> │               │
│ │             self = <httpx.Client object at 0x103401d60>                     │               │
│ │           stream = False                                                    │               │
│ ╰─────────────────────────────────────────────────────────────────────────────╯               │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_client.py:942 in           │
│ _send_handling_auth                                                                           │
│                                                                                               │
│    939 │   │   │   request = next(auth_flow)                                                  │
│    940 │   │   │                                                                              │
│    941 │   │   │   while True:                                                                │
│ ❱  942 │   │   │   │   response = self._send_handling_redirects(                              │
│    943 │   │   │   │   │   request,                                                           │
│    944 │   │   │   │   │   follow_redirects=follow_redirects,                                 │
│    945 │   │   │   │   │   history=history,                                                   │
│                                                                                               │
│ ╭────────────────────────────────── locals ───────────────────────────────────╮               │
│ │             auth = <httpx.Auth object at 0x103231490>                       │               │
│ │        auth_flow = <generator object Auth.sync_auth_flow at 0x1036a5380>    │               │
│ │ follow_redirects = False                                                    │               │
│ │          history = []                                                       │               │
│ │          request = <Request('POST', 'http://localhost:8000/v1/auth/login')> │               │
│ │             self = <httpx.Client object at 0x103401d60>                     │               │
│ ╰─────────────────────────────────────────────────────────────────────────────╯               │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_client.py:979 in           │
│ _send_handling_redirects                                                                      │
│                                                                                               │
│    976 │   │   │   for hook in self._event_hooks["request"]:                                  │
│    977 │   │   │   │   hook(request)                                                          │
│    978 │   │   │                                                                              │
│ ❱  979 │   │   │   response = self._send_single_request(request)                              │
│    980 │   │   │   try:                                                                       │
│    981 │   │   │   │   for hook in self._event_hooks["response"]:                             │
│    982 │   │   │   │   │   hook(response)                                                     │
│                                                                                               │
│ ╭────────────────────────────────── locals ───────────────────────────────────╮               │
│ │ follow_redirects = False                                                    │               │
│ │          history = []                                                       │               │
│ │          request = <Request('POST', 'http://localhost:8000/v1/auth/login')> │               │
│ │             self = <httpx.Client object at 0x103401d60>                     │               │
│ ╰─────────────────────────────────────────────────────────────────────────────╯               │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_client.py:1014 in          │
│ _send_single_request                                                                          │
│                                                                                               │
│   1011 │   │   │   )                                                                          │
│   1012 │   │                                                                                  │
│   1013 │   │   with request_context(request=request):                                         │
│ ❱ 1014 │   │   │   response = transport.handle_request(request)                               │
│   1015 │   │                                                                                  │
│   1016 │   │   assert isinstance(response.stream, SyncByteStream)                             │
│   1017                                                                                        │
│                                                                                               │
│ ╭─────────────────────────────── locals ───────────────────────────────╮                      │
│ │   request = <Request('POST', 'http://localhost:8000/v1/auth/login')> │                      │
│ │      self = <httpx.Client object at 0x103401d60>                     │                      │
│ │     start = 92025.636690375                                          │                      │
│ │ transport = <httpx.HTTPTransport object at 0x1030870b0>              │                      │
│ ╰──────────────────────────────────────────────────────────────────────╯                      │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_transports/default.py:249  │
│ in handle_request                                                                             │
│                                                                                               │
│   246 │   │   │   content=request.stream,                                                     │
│   247 │   │   │   extensions=request.extensions,                                              │
│   248 │   │   )                                                                               │
│ ❱ 249 │   │   with map_httpcore_exceptions():                                                 │
│   250 │   │   │   resp = self._pool.handle_request(req)                                       │
│   251 │   │                                                                                   │
│   252 │   │   assert isinstance(resp.stream, typing.Iterable)                                 │
│                                                                                               │
│ ╭───────────────────────────────────────── locals ──────────────────────────────────────────╮ │
│ │ httpcore = <module 'httpcore' from                                                        │ │
│ │            '/Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpcore/__init_… │ │
│ │      req = <Request [b'POST']>                                                            │ │
│ │  request = <Request('POST', 'http://localhost:8000/v1/auth/login')>                       │ │
│ │     self = <httpx.HTTPTransport object at 0x1030870b0>                                    │ │
│ ╰───────────────────────────────────────────────────────────────────────────────────────────╯ │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/contextlib.py:158 in __exit__                   │
│                                                                                               │
│   155 │   │   │   │   # tell if we get the same exception back                                │
│   156 │   │   │   │   value = typ()                                                           │
│   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                 │
│                                                                                               │
│ ╭────────────────────────────────── locals ───────────────────────────────────╮               │
│ │      self = <contextlib._GeneratorContextManager object at 0x1036b73e0>     │               │
│ │ traceback = <traceback object at 0x1036cb2c0>                               │               │
│ │     value = ReadError(ConnectionResetError(54, 'Connection reset by peer')) │               │
│ ╰─────────────────────────────────────────────────────────────────────────────╯               │
│                                                                                               │
│ /Users/rishabhkumar/miniforge3/lib/python3.12/site-packages/httpx/_transports/default.py:118  │
│ in map_httpcore_exceptions                                                                    │
│                                                                                               │
│   115 │   │   │   raise                                                                       │
│   116 │   │                                                                                   │
│   117 │   │   message = str(exc)                                                              │
│ ❱ 118 │   │   raise mapped_exc(message) from exc                                              │
│   119                                                                                         │
│   120                                                                                         │
│   121 class ResponseStream(SyncByteStream):                                                   │
│                                                                                               │
│ ╭──────────────────── locals ─────────────────────╮                                           │
│ │ message = '[Errno 54] Connection reset by peer' │                                           │
│ ╰─────────────────────────────────────────────────╯                                           │
╰───────────────────────────────────────────────────────────────────────────────────────────────╯
ReadError: [Errno 54] Connection reset by peer
