zenml-io / zenml

ZenML 🙏: The bridge between ML and Ops. https://zenml.io.
https://zenml.io
Apache License 2.0
4.07k stars 437 forks source link

[BUG]: S3 artifact store 400 error (connection timeout doubted) #2867

Open raymundlin opened 3 months ago

raymundlin commented 3 months ago

Contact Details [Optional]

No response

System Information

ZENML_LOCAL_VERSION: 0.61.0 ZENML_SERVER_VERSION: 0.61.0 ZENML_SERVER_DATABASE: sqlite ZENML_SERVER_DEPLOYMENT_TYPE: other ZENML_CONFIG_DIR: /home/raymund/.config/zenml ZENML_LOCAL_STORE_DIR: /home/raymund/.config/zenml/local_stores ZENML_SERVER_URL: http://192.168.0.100:8080 ZENML_ACTIVE_REPOSITORY_ROOT: /home/raymund/Documents/ftune-hq PYTHON_VERSION: 3.10.14 ENVIRONMENT: native SYSTEM_INFO: {'os': 'linux', 'linux_distro': 'ubuntu', 'linux_distro_like': 'debian', 'linux_distro_version': '24.04'} ACTIVE_WORKSPACE: default ACTIVE_STACK: s3store_stack ACTIVE_USER: lab TELEMETRY_STATUS: enabled ANALYTICS_CLIENT_ID: 5efcfb28-f5b0-44d7-be5f-7e06cf8909fc ANALYTICS_USER_ID: 518c5278-9025-4d9d-87ec-a760547355c2 ANALYTICS_SERVER_ID: 37313583-62d5-4a91-8a12-209bbf468827 INTEGRATIONS: ['airflow', 'bitbucket', 'kaniko', 'pigeon', 'pytorch', 's3'] PACKAGES: {'certifi': '2024.7.4', 'fsspec': '2024.6.1', 's3fs': '2024.6.1', 'regex': '2024.5.15', 'tzdata': '2024.1', 'pytz': '2024.1', 'setuptools': '65.5.0', 'pip': '24.1.2', 'packaging': '24.1', 'attrs': '23.2.0', 'pyarrow': '16.1.0', 'rich': '13.7.1', 'nvidia-nvjitlink-cu12': '12.5.82', 'nvidia-cuda-nvrtc-cu12': '12.1.105', 'nvidia-cuda-cupti-cu12': '12.1.105', 'nvidia-nvtx-cu12': '12.1.105', 'nvidia-cuda-runtime-cu12': '12.1.105', 'nvidia-cublas-cu12': '12.1.3.1', 'nvidia-cusparse-cu12': '12.1.0.106', 'nvidia-cusolver-cu12': '11.4.5.107', 'nvidia-cufft-cu12': '11.0.2.54', 'nvidia-curand-cu12': '10.3.2.106', 'ipython': '8.26.0', 'nvidia-cudnn-cu12': '8.9.2.26', 'ipywidgets': '8.1.3', 'click': '8.1.3', 'configparser': '7.0.0', 'docker': '6.1.3', 'multidict': '6.0.5', 'pyyaml': '6.0.1', 'psutil': '6.0.0', 'traitlets': '5.14.3', 'decorator': '5.1.1', 'smmap': '5.0.1', 'tqdm': '4.66.4', 'transformers': '4.42.3', 'typing-extensions': '4.12.2', 'pexpect': '4.9.0', 'widgetsnbextension': '4.0.11', 'gitdb': '4.0.11', 'async-timeout': '4.0.3', 'bcrypt': '4.0.1', 'filelock': '3.15.4', 'aiohttp': '3.9.5', 'idna': '3.7', 'xxhash': '3.4.1', 'charset-normalizer': '3.3.2', 'networkx': '3.3', 'gitpython': '3.1.43', 'jinja2': '3.1.4', 'prompt-toolkit': '3.0.47', 'jupyterlab-widgets': '3.0.11', 'greenlet': '3.0.3', 'markdown-it-py': '3.0.0', 'requests': '2.31.0', 'nvidia-nccl-cu12': '2.20.5', 'datasets': '2.19.1', 'pydantic-core': '2.18.4', 'pygments': '2.18.0', 'aiobotocore': '2.13.1', 'python-dateutil': '2.9.0.post0', 'pydantic': '2.7.4', 'pyparsing': '2.4.7', 'asttokens': '2.4.1', 'torch': '2.3.1', 'triton': '2.3.1', 'pandas': '2.2.2', 'urllib3': '2.2.2', 'pydantic-settings': '2.2.1', 'cloudpickle': '2.2.1', 'markupsafe': '2.1.5', 'sqlalchemy': '2.0.31', 'executing': '2.0.1', 'boto3': '1.34.131', 'botocore': '1.34.131', 'numpy': '1.26.4', 'wrapt': '1.16.0', 'six': '1.16.0', 'sympy': '1.12.1', 'yarl': '1.9.4', 'distro': '1.9.0', 'alembic': '1.8.1', 'websocket-client': '1.8.0', 'passlib': '1.7.4', 'frozenlist': '1.4.1', 'argparse': '1.4.0', 'mako': '1.3.5', 'aiosignal': '1.3.1', 'mpmath': '1.3.0', 'exceptiongroup': '1.2.1', 'pymysql': '1.1.1', 'python-dotenv': '1.0.1', 'jmespath': '1.0.1', 'multiprocess': '0.70.16', 'zenml': '0.61.0', 'bitsandbytes': '0.43.1', 'sqlalchemy-utils': '0.41.2', 'accelerate': '0.32.1', 'huggingface-hub': '0.23.4', 'jedi': '0.19.1', 'httplib2': '0.19.1', 'tokenizers': '0.19.1', 'validators': '0.18.2', 'peft': '0.11.1', 'aioitertools': '0.11.0', 's3transfer': '0.10.2', 'parso': '0.8.4', 'aws-profile-manager': '0.7.3', 'ptyprocess': '0.7.0', 'annotated-types': '0.7.0', 'stack-data': '0.6.3', 'pyarrow-hotfix': '0.6', 'safetensors': '0.4.3', 'dill': '0.3.8', 'secure': '0.3.0', 'click-params': '0.3.0', 'wcwidth': '0.2.13', 'pure-eval': '0.2.2', 'comm': '0.2.2', 'matplotlib-inline': '0.1.7', 'mdurl': '0.1.2', 'sqlmodel': '0.0.18'}

CURRENT STACK

Name: s3store_stack ID: f5a870ff-2c25-4e63-aa5b-4b90acaa9c64 User: lab / 518c5278-9025-4d9d-87ec-a760547355c2 Workspace: default / ec65075d-7856-48f9-a5ea-10eb3f063bac

ORCHESTRATOR: default

Name: default ID: 5b8cf94c-0231-4860-9b7b-71d701cf866d Type: orchestrator Flavor: local Configuration: {} Workspace: default / ec65075d-7856-48f9-a5ea-10eb3f063bac

ARTIFACT_STORE: s3_store

Name: s3_store ID: bee9c341-3cc6-48dc-b764-21f63b1924ea Type: artifact_store Flavor: s3 Configuration: {'authentication_secret': 's3_secret', 'path': 's3://labyrinth', 'key': '****', 'secret': '****', 'token': '****', 'client_kwargs': {'endpoint_url': 'http://192.168.0.100:9000', 'region_name': 'taipei'}, 'config_kwargs': None, 's3_additional_kwargs': None} User: lab / 518c5278-9025-4d9d-87ec-a760547355c2 Workspace: default / ec65075d-7856-48f9-a5ea-10eb3f063bac

What happened?

I set S3 artifact store in my stack, python run.py. After 5 min, it failed with: ClientError: An error occurred (400) when calling the HeadObject operation: Bad Request

I checked Stackoverflow; people said the above error could be caused by token expiry. Then I check zenml codes and the underlying s3fs codes. It seems that s3fs has a 5-minute timeout default for connections. connect_timeout = 5

I checked my MinIO trace, the window is truely 5 min.

I am considering adding that timeout parameter to the zenml config, but dont know how and where.

Since the error occurred after a long-duration fine-tuning process, I wonder: Maybe S3ArtifactStore should auto re-connect? Instead of throwing out the 400 error. Therefore this bug report.

Reproduction steps

zenml artifact-store register s3_store -f s3 --path='s3://labyrinth' --authentication_secret=s3_secret --client_kwargs='{"endpoint_url": "http://192.168.0.100:9000", "region_name": "taipei"}'

zenml stack register s3store_stack -a s3_store -o default --set

python run.py

Relevant log output

Pipeline run finetune_pipeline_A-2024_07_18-03_06_55_631940 failed.
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/s3fs/core.py:113 in          │
│ _error_wrapper                                                                                   │
│                                                                                                  │
│    110 │   │   kwargs = {}                                                                       │
│    111 │   for i in range(retries):                                                              │
│    112 │   │   try:                                                                              │
│ ❱  113 │   │   │   return await func(*args, **kwargs)                                            │
│    114 │   │   except S3_RETRYABLE_ERRORS as e:                                                  │
│    115 │   │   │   err = e                                                                       │
│    116 │   │   │   logger.debug("Retryable error: %s", e)                                        │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/aiobotocore/client.py:411 in │
│ _make_api_call                                                                                   │
│                                                                                                  │
│   408 │   │   │   │   "Code"                                                                     │
│   409 │   │   │   )                                                                              │
│   410 │   │   │   error_class = self.exceptions.from_code(error_code)                            │
│ ❱ 411 │   │   │   raise error_class(parsed_response, operation_name)                             │
│   412 │   │   else:                                                                              │
│   413 │   │   │   return parsed_response                                                         │
│   414                                                                                            │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ClientError: An error occurred (400) when calling the HeadObject operation: Bad Request

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

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/raymund/Documents/ftune-hq/run.py:221 in <module>                                          │
│                                                                                                  │
│   218                                                                                            │
│   219                                                                                            │
│   220 if __name__ == "__main__":                                                                 │
│ ❱ 221 │   run = finetune_pipeline_A()                                                            │
│   222                                                                                            │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/new/pipelines/pipeline │
│ .py:1410 in __call__                                                                             │
│                                                                                                  │
│   1407 │   │   │   return self.entrypoint(*args, **kwargs)                                       │
│   1408 │   │                                                                                     │
│   1409 │   │   self.prepare(*args, **kwargs)                                                     │
│ ❱ 1410 │   │   return self._run(**self._run_args)                                                │
│   1411 │                                                                                         │
│   1412 │   def _call_entrypoint(self, *args: Any, **kwargs: Any) -> None:                        │
│   1413 │   │   """Calls the pipeline entrypoint function with the given arguments.               │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/new/pipelines/pipeline │
│ .py:760 in _run                                                                                  │
│                                                                                                  │
│    757 │   │   │   │   │   │   "`zenml up`."                                                     │
│    758 │   │   │   │   │   )                                                                     │
│    759 │   │   │                                                                                 │
│ ❱  760 │   │   │   deploy_pipeline(                                                              │
│    761 │   │   │   │   deployment=deployment_model, stack=stack, placeholder_run=run             │
│    762 │   │   │   )                                                                             │
│    763 │   │   │   if run:                                                                       │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/new/pipelines/run_util │
│ s.py:142 in deploy_pipeline                                                                      │
│                                                                                                  │
│   139 │   │   │   # placeholder run to stay in the database                                      │
│   140 │   │   │   Client().delete_pipeline_run(placeholder_run.id)                               │
│   141 │   │                                                                                      │
│ ❱ 142 │   │   raise e                                                                            │
│   143 │   finally:                                                                               │
│   144 │   │   constants.SHOULD_PREVENT_PIPELINE_EXECUTION = previous_value                       │
│   145                                                                                            │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/new/pipelines/run_util │
│ s.py:130 in deploy_pipeline                                                                      │
│                                                                                                  │
│   127 │   previous_value = constants.SHOULD_PREVENT_PIPELINE_EXECUTION                           │
│   128 │   constants.SHOULD_PREVENT_PIPELINE_EXECUTION = True                                     │
│   129 │   try:                                                                                   │
│ ❱ 130 │   │   stack.deploy_pipeline(deployment=deployment)                                       │
│   131 │   except Exception as e:                                                                 │
│   132 │   │   if (                                                                               │
│   133 │   │   │   placeholder_run                                                                │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/stack/stack.py:853 in  │
│ deploy_pipeline                                                                                  │
│                                                                                                  │
│    850 │   │   Returns:                                                                          │
│    851 │   │   │   The return value of the call to `orchestrator.run_pipeline(...)`.             │
│    852 │   │   """                                                                               │
│ ❱  853 │   │   return self.orchestrator.run(deployment=deployment, stack=self)                   │
│    854 │                                                                                         │
│    855 │   def _get_active_components_for_step(                                                  │
│    856 │   │   self, step_config: "StepConfiguration"                                            │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/base_orc │
│ hestrator.py:178 in run                                                                          │
│                                                                                                  │
│   175 │   │   environment = get_config_environment_vars(deployment=deployment)                   │
│   176 │   │                                                                                      │
│   177 │   │   try:                                                                               │
│ ❱ 178 │   │   │   result = self.prepare_or_run_pipeline(                                         │
│   179 │   │   │   │   deployment=deployment, stack=stack, environment=environment                │
│   180 │   │   │   )                                                                              │
│   181 │   │   finally:                                                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/local/lo │
│ cal_orchestrator.py:78 in prepare_or_run_pipeline                                                │
│                                                                                                  │
│    75 │   │   │   │   │   step_name,                                                             │
│    76 │   │   │   │   )                                                                          │
│    77 │   │   │                                                                                  │
│ ❱  78 │   │   │   self.run_step(                                                                 │
│    79 │   │   │   │   step=step,                                                                 │
│    80 │   │   │   )                                                                              │
│    81                                                                                            │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/base_orc │
│ hestrator.py:198 in run_step                                                                     │
│                                                                                                  │
│   195 │   │   │   step=step,                                                                     │
│   196 │   │   │   orchestrator_run_id=self.get_orchestrator_run_id(),                            │
│   197 │   │   )                                                                                  │
│ ❱ 198 │   │   launcher.launch()                                                                  │
│   199 │                                                                                          │
│   200 │   @staticmethod                                                                          │
│   201 │   def requires_resources_in_orchestration_environment(                                   │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/step_lau │
│ ncher.py:268 in launch                                                                           │
│                                                                                                  │
│   265 │   │   │   │   │   │   │   │   │   return None                                            │
│   266 │   │   │   │   │   │   │   │                                                              │
│   267 │   │   │   │   │   │   │   │   force_write_logs = _bypass                                 │
│ ❱ 268 │   │   │   │   │   │   │   self._run_step(                                                │
│   269 │   │   │   │   │   │   │   │   pipeline_run=pipeline_run,                                 │
│   270 │   │   │   │   │   │   │   │   step_run=step_run_response,                                │
│   271 │   │   │   │   │   │   │   │   last_retry=last_retry,                                     │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/step_lau │
│ ncher.py:475 in _run_step                                                                        │
│                                                                                                  │
│   472 │   │   │   │   │   last_retry=last_retry,                                                 │
│   473 │   │   │   │   )                                                                          │
│   474 │   │   │   else:                                                                          │
│ ❱ 475 │   │   │   │   self._run_step_without_step_operator(                                      │
│   476 │   │   │   │   │   pipeline_run=pipeline_run,                                             │
│   477 │   │   │   │   │   step_run=step_run,                                                     │
│   478 │   │   │   │   │   step_run_info=step_run_info,                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/step_lau │
│ ncher.py:559 in _run_step_without_step_operator                                                  │
│                                                                                                  │
│   556 │   │   if last_retry:                                                                     │
│   557 │   │   │   os.environ[ENV_ZENML_IGNORE_FAILURE_HOOK] = "false"                            │
│   558 │   │   runner = StepRunner(step=self._step, stack=self._stack)                            │
│ ❱ 559 │   │   runner.run(                                                                        │
│   560 │   │   │   pipeline_run=pipeline_run,                                                     │
│   561 │   │   │   step_run=step_run,                                                             │
│   562 │   │   │   input_artifacts=input_artifacts,                                               │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/step_run │
│ ner.py:252 in run                                                                                │
│                                                                                                  │
│   249 │   │   │   │   │   │   │   is_enabled_on_step=step_run_info.config.enable_artifact_visu   │
│   250 │   │   │   │   │   │   │   is_enabled_on_pipeline=step_run_info.pipeline.enable_artifac   │
│   251 │   │   │   │   │   │   )                                                                  │
│ ❱ 252 │   │   │   │   │   │   output_artifact_ids = self._store_output_artifacts(                │
│   253 │   │   │   │   │   │   │   output_data=output_data,                                       │
│   254 │   │   │   │   │   │   │   output_artifact_uris=output_artifact_uris,                     │
│   255 │   │   │   │   │   │   │   output_materializers=output_materializers,                     │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/orchestrators/step_run │
│ ner.py:624 in _store_output_artifacts                                                            │
│                                                                                                  │
│   621 │   │   │   # Get full set of tags                                                         │
│   622 │   │   │   tags = step_context.get_output_tags(output_name)                               │
│   623 │   │   │                                                                                  │
│ ❱ 624 │   │   │   artifact = save_artifact(                                                      │
│   625 │   │   │   │   name=artifact_name,                                                        │
│   626 │   │   │   │   data=return_value,                                                         │
│   627 │   │   │   │   materializer=materializer_class,                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/artifacts/utils.py:183 │
│ in save_artifact                                                                                 │
│                                                                                                  │
│   180 │   # Save the artifact to the artifact store                                              │
│   181 │   data_type = type(data)                                                                 │
│   182 │   materializer_object.validate_type_compatibility(data_type)                             │
│ ❱ 183 │   materializer_object.save(data)                                                         │
│   184 │                                                                                          │
│   185 │   # Save visualizations of the artifact                                                  │
│   186 │   visualizations: List[ArtifactVisualizationRequest] = []                                │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/labshared/materializers/directory_materializer.py:55 in save    │
│                                                                                                  │
│   52 │   │   │   data: Path to a local directory to store.                                       │
│   53 │   │   """                                                                                 │
│   54 │   │   assert isinstance(data, Path)                                                       │
│ ❱ 55 │   │   self._copy_directory(src=str(data), dst=self.uri)                                   │
│   56 │   │   shutil.rmtree(data)  # clean-up locally stored data                                 │
│   57 │                                                                                           │
│   58 │   @staticmethod                                                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/labshared/materializers/directory_materializer.py:73 in         │
│ _copy_directory                                                                                  │
│                                                                                                  │
│   70 │   │   │   for file in files:                                                              │
│   71 │   │   │   │   src_file = os.path.join(src_dir, file)                                      │
│   72 │   │   │   │   dst_file = os.path.join(dst_dir, file)                                      │
│ ❱ 73 │   │   │   │   fileio.copy(src_file, dst_file)                                             │
│   74                                                                                             │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/io/fileio.py:85 in     │
│ copy                                                                                             │
│                                                                                                  │
│    82 │   if src_fs is dst_fs:                                                                   │
│    83 │   │   src_fs.copyfile(src, dst, overwrite=overwrite)                                     │
│    84 │   else:                                                                                  │
│ ❱  85 │   │   if not overwrite and exists(dst):                                                  │
│    86 │   │   │   raise FileExistsError(                                                         │
│    87 │   │   │   │   f"Destination file '{convert_to_str(dst)}' already exists "                │
│    88 │   │   │   │   f"and `overwrite` is false."                                               │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/io/fileio.py:106 in    │
│ exists                                                                                           │
│                                                                                                  │
│   103 │   Returns:                                                                               │
│   104 │   │   `True` if the given path exists, `False` otherwise.                                │
│   105 │   """                                                                                    │
│ ❱ 106 │   return _get_filesystem(path).exists(path)                                              │
│   107                                                                                            │
│   108                                                                                            │
│   109 def glob(pattern: "PathType") -> List["PathType"]:                                         │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/artifact_stores/base_a │
│ rtifact_store.py:168 in __call__                                                                 │
│                                                                                                  │
│   165 │   │   │   for key, value in kwargs.items()                                               │
│   166 │   │   }                                                                                  │
│   167 │   │                                                                                      │
│ ❱ 168 │   │   return self.func(*args, **kwargs)                                                  │
│   169                                                                                            │
│   170                                                                                            │
│   171 class BaseArtifactStoreConfig(StackComponentConfig):                                       │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/zenml/integrations/s3/artifa │
│ ct_stores/s3_artifact_store.py:255 in exists                                                     │
│                                                                                                  │
│   252 │   │   Returns:                                                                           │
│   253 │   │   │   True if the path exists, False otherwise.                                      │
│   254 │   │   """                                                                                │
│ ❱ 255 │   │   return self.filesystem.exists(path=path)  # type: ignore[no-any-return]            │
│   256 │                                                                                          │
│   257 │   def glob(self, pattern: PathType) -> List[PathType]:                                   │
│   258 │   │   """Return all paths that match the given glob pattern.                             │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/fsspec/asyn.py:118 in        │
│ wrapper                                                                                          │
│                                                                                                  │
│    115 │   @functools.wraps(func)                                                                │
│    116 │   def wrapper(*args, **kwargs):                                                         │
│    117 │   │   self = obj or args[0]                                                             │
│ ❱  118 │   │   return sync(self.loop, func, *args, **kwargs)                                     │
│    119 │                                                                                         │
│    120 │   return wrapper                                                                        │
│    121                                                                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/fsspec/asyn.py:103 in sync   │
│                                                                                                  │
│    100 │   │   # suppress asyncio.TimeoutError, raise FSTimeoutError                             │
│    101 │   │   raise FSTimeoutError from return_result                                           │
│    102 │   elif isinstance(return_result, BaseException):                                        │
│ ❱  103 │   │   raise return_result                                                               │
│    104 │   else:                                                                                 │
│    105 │   │   return return_result                                                              │
│    106                                                                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/fsspec/asyn.py:56 in _runner │
│                                                                                                  │
│     53 │   if timeout is not None:                                                               │
│     54 │   │   coro = asyncio.wait_for(coro, timeout=timeout)                                    │
│     55 │   try:                                                                                  │
│ ❱   56 │   │   result[0] = await coro                                                            │
│     57 │   except Exception as ex:                                                               │
│     58 │   │   result[0] = ex                                                                    │
│     59 │   finally:                                                                              │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/s3fs/core.py:1061 in _exists │
│                                                                                                  │
│   1058 │   │   │   │   return exists_in_cache                                                    │
│   1059 │   │   │                                                                                 │
│   1060 │   │   │   try:                                                                          │
│ ❱ 1061 │   │   │   │   await self._info(path, bucket, key, version_id=version_id)                │
│   1062 │   │   │   │   return True                                                               │
│   1063 │   │   │   except FileNotFoundError:                                                     │
│   1064 │   │   │   │   return False                                                              │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/s3fs/core.py:1374 in _info   │
│                                                                                                  │
│   1371 │   │   │   │   │   return {"name": path, "size": 0, "type": "directory"}                 │
│   1372 │   │   if key:                                                                           │
│   1373 │   │   │   try:                                                                          │
│ ❱ 1374 │   │   │   │   out = await self._call_s3(                                                │
│   1375 │   │   │   │   │   "head_object",                                                        │
│   1376 │   │   │   │   │   self.kwargs,                                                          │
│   1377 │   │   │   │   │   Bucket=bucket,                                                        │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/s3fs/core.py:365 in _call_s3 │
│                                                                                                  │
│    362 │   │   kw2.pop("Body", None)                                                             │
│    363 │   │   logger.debug("CALL: %s - %s - %s", method.__name__, akwarglist, kw2)              │
│    364 │   │   additional_kwargs = self._get_s3_method_kwargs(method, *akwarglist, **kwargs)     │
│ ❱  365 │   │   return await _error_wrapper(                                                      │
│    366 │   │   │   method, kwargs=additional_kwargs, retries=self.retries                        │
│    367 │   │   )                                                                                 │
│    368                                                                                           │
│                                                                                                  │
│ /home/raymund/Documents/ftune-hq/.venv/lib/python3.10/site-packages/s3fs/core.py:145 in          │
│ _error_wrapper                                                                                   │
│                                                                                                  │
│    142 │   │   except Exception as e:                                                            │
│    143 │   │   │   err = e                                                                       │
│    144 │   err = translate_boto_error(err)                                                       │
│ ❱  145 │   raise err                                                                             │
│    146                                                                                           │
│    147                                                                                           │
│    148 def version_id_kw(version_id):                                                            │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
OSError: [Errno 22] Bad Request

Code of Conduct

htahir1 commented 2 months ago

@raymundlin so sorry for the delay here, somehow this slipped with internal processes changing. We'll take a look now if still relevant