Extending Experiment container from 2026-07-18 07:16 UTC to 2026-07-18 08:16 UTC... ╭───────────────────────────────────────────────────────────────────────────────── Traceback (most recent call last) ──────────────────────────────────────────────────────────────────────────────────╮ │ /app/.venv/lib/python3.14/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 │ │ │ │ /app/.venv/lib/python3.14/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 │ │ │ │ /app/.venv/lib/python3.14/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. │ │ │ │ /app/.venv/lib/python3.14/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: │ │ │ │ /app/.venv/lib/python3.14/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", {}) │ │ │ │ /app/.venv/lib/python3.14/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 │ │ │ │ /app/.venv/lib/python3.14/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, │ │ │ │ /app/.venv/lib/python3.14/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 ( │ │ │ │ /app/.venv/lib/python3.14/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 │ │ │ │ /app/.venv/lib/python3.14/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 │ │ │ │ /usr/local/lib/python3.14/contextlib.py:162 in __exit__ │ │ │ │ 159 │ │ │ │ # tell if we get the same exception back │ │ 160 │ │ │ │ value = typ() │ │ 161 │ │ │ try: │ │ ❱ 162 │ │ │ │ self.gen.throw(value) │ │ 163 │ │ │ except StopIteration as exc: │ │ 164 │ │ │ │ # Suppress StopIteration *unless* it's the same exception that │ │ 165 │ │ │ │ # was passed to throw(). This prevents a StopIteration │ │ │ │ /app/.venv/lib/python3.14/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 │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ReadTimeout: The read operation timed out The above exception was the direct cause of the following exception: ╭───────────────────────────────────────────────────────────────────────────────── Traceback (most recent call last) ──────────────────────────────────────────────────────────────────────────────────╮ │ /app/.venv/lib/python3.14/site-packages/slices_cli_bi/commands/bi_helpers.py:83 in wrapper_handle_some_exceptions │ │ │ │ 80 │ def wrapper_handle_some_exceptions(*args, **kwargs): │ │ 81 │ │ """Function wrapper for handle_some_exceptions.""" # noqa: D401 │ │ 82 │ │ try: │ │ ❱ 83 │ │ │ return func(*args, **kwargs) │ │ 84 │ │ except ApiResponseError as e: │ │ 85 │ │ │ if e._httpx_status_error.response.status_code in ( │ │ 86 │ │ │ │ 502, │ │ │ │ /app/.venv/lib/python3.14/site-packages/slices_cli_bi/commands/bi.py:1989 in extend_resource │ │ │ │ 1986 │ │ │ f"Extending Experiment container from {friendly_datetime(exp.expires_at)} " │ │ 1987 │ │ │ f"to {friendly_datetime(new_expires_at)}..." │ │ 1988 │ │ ) │ │ ❱ 1989 │ │ ctx.obj.api.experiment.update( │ │ 1990 │ │ │ exp.id, │ │ 1991 │ │ │ exp.project_id, │ │ 1992 │ │ │ expires_at=new_expires_at, │ │ │ │ /app/.venv/lib/python3.14/site-packages/slices_clientlib_core/experiment.py:202 in update │ │ │ │ 199 │ │ │ if field_value is not None │ │ 200 │ │ } │ │ 201 │ │ │ │ ❱ 202 │ │ update_data["project_token"] = self._project_client.get_jwt(project_id) │ │ 203 │ │ │ │ 204 │ │ response = self._client.put( │ │ 205 │ │ │ f"{self.API_BASE_PATH}{experiment_id}", │ │ │ │ /app/.venv/lib/python3.14/site-packages/slices_clientlib_core/project.py:76 in get_jwt │ │ │ │ 73 │ │ │ 74 │ def get_jwt(self, id: str) -> str: │ │ 75 │ │ """Get project JWT.""" │ │ ❱ 76 │ │ response = self._client.get(f"{self.API_BASE_PATH}{id}", headers={"Accept": "application/jwt"}) │ │ 77 │ │ │ │ 78 │ │ try: │ │ 79 │ │ │ response.raise_for_status() │ │ │ │ /app/.venv/lib/python3.14/site-packages/httpx/_client.py:1053 in get │ │ │ │ 1050 │ │ │ │ 1051 │ │ **Parameters**: See `httpx.request`. │ │ 1052 │ │ """ │ │ ❱ 1053 │ │ return self.request( │ │ 1054 │ │ │ "GET", │ │ 1055 │ │ │ url, │ │ 1056 │ │ │ params=params, │ │ │ │ /app/.venv/lib/python3.14/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( │ │ │ │ /app/.venv/lib/python3.14/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, │ │ │ │ /app/.venv/lib/python3.14/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, │ │ │ │ /app/.venv/lib/python3.14/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) │ │ │ │ /app/.venv/lib/python3.14/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 │ │ │ │ /app/.venv/lib/python3.14/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) │ │ │ │ /usr/local/lib/python3.14/contextlib.py:162 in __exit__ │ │ │ │ 159 │ │ │ │ # tell if we get the same exception back │ │ 160 │ │ │ │ value = typ() │ │ 161 │ │ │ try: │ │ ❱ 162 │ │ │ │ self.gen.throw(value) │ │ 163 │ │ │ except StopIteration as exc: │ │ 164 │ │ │ │ # Suppress StopIteration *unless* it's the same exception that │ │ 165 │ │ │ │ # was passed to throw(). This prevents a StopIteration │ │ │ │ /app/.venv/lib/python3.14/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): │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ReadTimeout: The read operation timed out