Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

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

Open
1 task done
raymundlin opened this issue Jul 18, 2024 · 1 comment
Open
1 task done

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

raymundlin opened this issue Jul 18, 2024 · 1 comment
Labels
bug Something isn't working

Comments

@raymundlin
Copy link

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

  • I agree to follow this project's Code of Conduct
@raymundlin raymundlin added the bug Something isn't working label Jul 18, 2024
@htahir1
Copy link
Contributor

htahir1 commented Aug 22, 2024

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

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
bug Something isn't working
Projects
None yet
Development

No branches or pull requests

2 participants