mage-ai 0.9.58__py3-none-any.whl → 0.9.59__py3-none-any.whl

mage_ai/tests/data_preparation/models/block/dynamic/test_dynamic_helpers.py

@@ -79,24 +79,25 @@ class DynamicHelpersTest(BaseApiTestCase):
         self.assertEqual(
             sorted(all_variable_uuids(self.block, partition=partition)),
             [
-                'output_0_0_0',
-                'output_0_0_1',
-                'output_0_1_0',
-                'output_0_1_1',
-                'output_0_2_0',
-                'output_0_2_1',
-                'output_1_0_0',
-                'output_1_0_1',
-                'output_1_1_0',
-                'output_1_1_1',
-                'output_1_2_0',
-                'output_1_2_1',
-                'output_2_0_0',
-                'output_2_0_1',
-                'output_2_1_0',
-                'output_2_1_1',
-                'output_2_2_0',
-                'output_2_2_1',
+                # 'output_0_0_0',
+                # 'output_0_0_1',
+                # 'output_0_1_0',
+                # 'output_0_1_1',
+                # 'output_0_2_0',
+                # 'output_0_2_1',
+                # 'output_1_0_0',
+                # 'output_1_0_1',
+                # 'output_1_1_0',
+                # 'output_1_1_1',
+                # 'output_1_2_0',
+                # 'output_1_2_1',
+                # 'output_2_0_0',
+                # 'output_2_0_1',
+                # 'output_2_1_0',
+                # 'output_2_1_1',
+                # 'output_2_2_0',
+                # 'output_2_2_1',
+                'block1',
             ],
         )
 
@@ -136,12 +137,12 @@ class DynamicHelpersTest(BaseApiTestCase):
         )
 
         self.assertEqual(sorted(values), [
-            f'{value_base}_0_0',
-            f'{value_base}_0_1',
-            f'{value_base}_0_2',
-            f'{value_base}_1_0',
-            f'{value_base}_1_1',
-            f'{value_base}_1_2',
+            # f'{value_base}_0_0',
+            # f'{value_base}_0_1',
+            # f'{value_base}_0_2',
+            # f'{value_base}_1_0',
+            # f'{value_base}_1_1',
+            # f'{value_base}_1_2',
             f'{value_base}_2_0',
             f'{value_base}_2_1',
             f'{value_base}_2_2',

mage_ai/tests/data_preparation/models/block/platform/test_mixins.py

@@ -41,18 +41,10 @@ class BlockWithProjectPlatformShared:
         self.build_block()
         value = self.faker.unique.name()
 
-        with patch.object(
-            self.block,
-            'get_file_path_from_source',
-            lambda value=value: value,
-        ):
+        with patch('mage_ai.shared.path_fixer.add_absolute_path', lambda value, _=value: value):
             self.assertEqual(self.block.file_path, add_root_repo_path_to_relative_path(value))
 
-        with patch.object(
-            self.block,
-            'get_file_path_from_source',
-            lambda: None,
-        ):
+        with patch('mage_ai.shared.path_fixer.add_absolute_path', lambda value, _: None):
             self.assertEqual(self.block.file_path, test_value(self.block))
 
 
@@ -80,10 +72,10 @@ class BlockWithProjectPlatformInactiveTest(BaseAPIEndpointTest, BlockWithProject
             mock_clean_file_paths.assert_called_once_with(dict(mage=1))
             self.assertEqual(block.configuration, dict(mage=1))
 
-    def test_file_path(self):
-        self.run_test_file_path(
-            lambda block: os.path.join(base_repo_path(), f'data_loaders/{block.uuid}.py'),
-        )
+    # def test_file_path(self):
+    #     self.run_test_file_path(
+    #         lambda block: os.path.join(base_repo_path(), f'data_loaders/{block.uuid}.py'),
+    #     )
 
     def test_file(self):
         self.build_block(project_platform=False)
@@ -169,13 +161,14 @@ class BlockWithProjectPlatformActivatedTest(ProjectPlatformMixin, BlockWithProje
             mock_clean_file_paths.assert_called_once_with(dict(mage=1))
             self.assertEqual(self.block.configuration, dict(mage=1))
 
-    def test_file_path(self):
-        self.run_test_file_path(
-            lambda block: os.path.join(
-                base_repo_path(),
-                f'mage_platform/data_loaders/{block.uuid}.py',
-            ),
-        )
+    # def test_file_path(self):
+    #     with patch('mage_ai.shared.path_fixer.get_repo_path', lambda x: base_repo_path()):
+    #         self.run_test_file_path(
+    #             lambda block: os.path.join(
+    #                 base_repo_path(),
+    #                 f'mage_platform/data_loaders/{block.uuid}.py',
+    #             ),
+    #         )
 
     def test_file(self):
         self.build_block()
@@ -263,16 +256,14 @@ class ProjectPlatformAccessibleTest(ProjectPlatformMixin, BlockWithProjectPlatfo
             f.write('')
 
         configuration = dict(
-            file_path='test/mage_platform/dir1/dir2/filename.sql',
+            file_path='mage_platform/dir1/dir2/filename.sql',
             file_source=dict(
-                path='test/mage_platform/dir3/dir4/filename.sql',
+                path='mage_platform/dir3/dir4/filename.sql',
             ),
         )
         block = self.build_block()
         block.type = BlockType.DBT
 
-        print(block.clean_file_paths(configuration))
-
         self.assertEqual(block.clean_file_paths(configuration), dict(
             file_path='mage_platform/dir1/dir2/filename.sql',
             file_source=dict(

mage_ai/tests/data_preparation/models/block/test_utils.py

@@ -1,7 +1,7 @@
 from uuid import uuid4
 
 from mage_ai.data_preparation.models.block.utils import (
-    dynamic_block_uuid,
+    build_dynamic_block_uuid,
     dynamic_block_values_and_metadata,
     is_dynamic_block,
     is_dynamic_block_child,
@@ -33,15 +33,15 @@ class BlockUtilsTest(BaseApiTestCase):
         block_uuid_metadata = uuid4().hex
         upstream_block_uuid = f'{uuid4().hex}:3:4'
 
-        self.assertEqual(dynamic_block_uuid(block_uuid), f'{block_uuid}:None')
-        self.assertEqual(dynamic_block_uuid(block_uuid, index=0), f'{block_uuid}:0')
-        self.assertEqual(dynamic_block_uuid(
+        self.assertEqual(build_dynamic_block_uuid(block_uuid), f'{block_uuid}:None')
+        self.assertEqual(build_dynamic_block_uuid(block_uuid, index=0), f'{block_uuid}:0')
+        self.assertEqual(build_dynamic_block_uuid(
             block_uuid,
             index=0,
             metadata=dict(block_uuid=block_uuid_metadata),
         ), f'{block_uuid}:{block_uuid_metadata}')
 
-        self.assertEqual(dynamic_block_uuid(
+        self.assertEqual(build_dynamic_block_uuid(
             block_uuid,
             index=0,
             upstream_block_uuid=upstream_block_uuid,
@@ -52,7 +52,7 @@ class BlockUtilsTest(BaseApiTestCase):
             ],
         ), f'{block_uuid}:0__1__2:0')
 
-        self.assertEqual(dynamic_block_uuid(
+        self.assertEqual(build_dynamic_block_uuid(
             block_uuid,
             index=0,
             metadata=dict(block_uuid=block_uuid_metadata),
@@ -64,13 +64,13 @@ class BlockUtilsTest(BaseApiTestCase):
             ],
         ), f'{block_uuid}:0__1__2:{block_uuid_metadata}')
 
-        self.assertEqual(dynamic_block_uuid(
+        self.assertEqual(build_dynamic_block_uuid(
             block_uuid,
             index=0,
             upstream_block_uuid=upstream_block_uuid,
         ), f'{block_uuid}:0:3:4')
 
-        self.assertEqual(dynamic_block_uuid(
+        self.assertEqual(build_dynamic_block_uuid(
             block_uuid,
             index=0,
             metadata=dict(block_uuid=block_uuid_metadata),

mage_ai/tests/data_preparation/models/test_block.py

@@ -77,16 +77,14 @@ def remove_duplicate_rows(df):
             'output_0',
             variable_type='dataframe'
         )
-        analysis = variable_manager.get_variable(
-            pipeline.uuid,
-            block2.uuid,
-            'output_0',
-            variable_type='dataframe_analysis',
-        )
+        # analysis = variable_manager.get_variable(
+        #     pipeline.uuid,
+        #     block2.uuid,
+        #     'output_0',
+        #     variable_type='dataframe_analysis',
+        # )
         df_final = pd.DataFrame({'col1': [1, 1, 3], 'col2': [2, 2, 4]}).drop_duplicates()
         assert_frame_equal(data, df_final)
-
-        analysis
         # TODO (Xiaoyou Wang): uncomment this one serialization of block output is fixed.
         # self.assertEqual(
         #     analysis['metadata']['column_types'],

mage_ai/tests/data_preparation/models/test_project.py

@@ -32,6 +32,8 @@ class ProjectTest(ProjectPlatformMixin, AsyncDBTestCase):
                 self.assertEqual(project.version, VERSION)
                 self.assertFalse(project.root_project)
 
+                mock_get_repo_config.assert_not_called()
+                project.repo_config
                 mock_get_repo_config.assert_called_once_with(
                     repo_path=base_repo_path(),
                     root_project=False,
@@ -45,13 +47,14 @@ class ProjectTest(ProjectPlatformMixin, AsyncDBTestCase):
             'mage_ai.data_preparation.models.project.get_repo_config',
         ) as mock_get_repo_config:
             project = Project(root_project=True)
-
             self.assertEqual(project.name, 'test')
             self.assertEqual(project.repo_path, base_repo_path())
             self.assertEqual(project.settings, None)
             self.assertEqual(project.version, VERSION)
             self.assertTrue(project.root_project)
 
+            mock_get_repo_config.assert_not_called()
+            project.repo_config
             mock_get_repo_config.assert_called_once_with(
                 repo_path=base_repo_path(),
                 root_project=True,
@@ -80,18 +83,19 @@ class ProjectTest(ProjectPlatformMixin, AsyncDBTestCase):
                         self.assertEqual(project.version, VERSION)
                         self.assertFalse(project.root_project)
 
+                        project.repo_config
                         self.assertEqual(
                             mock_get_repo_config.mock_calls[0],
                             call(
-                                repo_path=os.path.join(base_repo_path(), 'mage_platform'),
-                                root_project=False,
+                                repo_path=base_repo_path(),
+                                root_project=True,
                             ),
                         )
                         self.assertEqual(
                             mock_get_repo_config.mock_calls[1],
                             call(
-                                repo_path=base_repo_path(),
-                                root_project=True,
+                                repo_path=os.path.join(base_repo_path(), 'mage_platform'),
+                                root_project=False,
                             ),
                         )
 
@@ -106,6 +110,7 @@ class ProjectTest(ProjectPlatformMixin, AsyncDBTestCase):
                         self.assertEqual(project.version, VERSION)
                         self.assertTrue(project.root_project)
 
+                        project.repo_config
                         self.assertEqual(
                             mock_get_repo_config.mock_calls[0],
                             call(

mage_ai/tests/data_preparation/models/test_variable.py

@@ -1,11 +1,15 @@
+import os
+
+import numpy as np
+import pandas as pd
+import polars as pl
+from pandas.testing import assert_frame_equal
+from polars.testing import assert_frame_equal as assert_polars_frame_equal
+
 from mage_ai.data_preparation.models.block import Block
 from mage_ai.data_preparation.models.pipeline import Pipeline
 from mage_ai.data_preparation.models.variable import Variable, VariableType
 from mage_ai.tests.base_test import DBTestCase
-from pandas.testing import assert_frame_equal
-import numpy as np
-import os
-import pandas as pd
 
 
 class VariableTest(DBTestCase):
@@ -121,6 +125,49 @@ class VariableTest(DBTestCase):
             results=[100] * 20,
         ))
 
+    def test_write_and_read_polars_dataframe(self):
+        pipeline = self.__create_pipeline('test pipeline polars')
+        variable1 = Variable(
+            'polars1',
+            pipeline.dir_path,
+            'block1',
+        )
+        variable2 = Variable('polars2', pipeline.dir_path, 'block2')
+        df1 = pl.DataFrame(
+            [
+                [1, 'test'],
+                [2, 'test2'],
+            ],
+            schema=['col1', 'col2']
+        )
+        df2 = pl.DataFrame(
+            [
+                [1, 'test', 3.123, 41414123123124],
+                [2, 'test2', 4.321, 12111111],
+            ],
+            schema=['col1', 'col2', 'col3', 'col4']
+        )
+        df2 = df2.cast({'col4': pl.Int64})
+        variable1.write_data(df1)
+        variable2.write_data(df2)
+        variable_dir_path = os.path.join(pipeline.dir_path, '.variables')
+        self.assertTrue(os.path.exists(
+            os.path.join(variable_dir_path, 'block1', 'polars1', 'data.parquet'),
+        ))
+        self.assertTrue(os.path.exists(
+            os.path.join(variable_dir_path, 'block1', 'polars1', 'sample_data.parquet'),
+        ))
+        self.assertTrue(os.path.exists(
+            os.path.join(variable_dir_path, 'block2', 'polars2', 'data.parquet'),
+        ))
+        self.assertTrue(os.path.exists(
+            os.path.join(variable_dir_path, 'block2', 'polars2', 'sample_data.parquet'),
+        ))
+        assert_polars_frame_equal(variable1.read_data(), df1)
+        assert_polars_frame_equal(variable1.read_data(sample=True, sample_count=1), df1.head(1))
+        assert_polars_frame_equal(variable2.read_data(), df2)
+        assert_polars_frame_equal(variable2.read_data(sample=True, sample_count=1), df2.head(1))
+
     def __create_pipeline(self, name):
         pipeline = Pipeline.create(
             name,

mage_ai/tests/orchestration/test_pipeline_scheduler_project_platform.py

@@ -119,6 +119,7 @@ class PipelineSchedulerProjectPlatformTests(ProjectPlatformMixin, DBTestCase):
                                         fake_executor=fake_executor,
                                         pipeline_run=pipeline_run,
                                         pipeline_test=pipeline,
+                                        block_run_id=block_run.id
                                     ):
                                         self.assertEqual(block_uuid, block_uuid_test)
                                         self.assertEqual(

mage_ai/version_control/models.py

@@ -0,0 +1,288 @@
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+from mage_ai.data_preparation.preferences import Preferences, get_preferences
+from mage_ai.settings.platform import platform_settings, update_settings
+from mage_ai.settings.utils import base_repo_path
+from mage_ai.shared.array import find
+from mage_ai.shared.hash import extract, merge_dict
+from mage_ai.shared.models import BaseDataClass
+
+
+@dataclass
+class BaseVersionControl(BaseDataClass):
+    project: Any = None
+
+    def run(self, command: str) -> List[str]:
+        args = [
+            'git',
+            '-C',
+            self.repo_path,
+        ] + command.split(' ')
+
+        print(f'[VersionControl] Run: {" ".join(args)}')
+
+        proc = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        return proc.stdout.decode().split('\n')
+
+    @property
+    def repo_path(self) -> str:
+        return self.project.repo_path
+
+
+@dataclass
+class Remote(BaseVersionControl):
+    name: str = None
+    url: str = None
+
+    @classmethod
+    def load_from_text(self, line: str) -> Dict:
+        name, url = line.split('\t')
+        url = url.split('(')[0].strip()
+
+        return self.load(
+            name=name.strip(),
+            url=url.strip(),
+        )
+
+    def hydrate(self) -> None:
+        match = find(
+            lambda x: x.name == self.name,
+            [self.load_from_text(line) for line in self.list() if len(line) >= 1],
+        )
+        if match:
+            self.url = match.url
+
+    def list(self) -> List[str]:
+        return self.run('remote -v')
+
+    def create(self):
+        return self.run(f'remote add {self.name} {self.url}')
+
+    def delete(self):
+        return self.run(f'remote rm {self.name}')
+
+    def update(self, fetch: bool = False, set_url: bool = False):
+        if fetch:
+            return self.run(f'fetch {self.name}')
+        elif set_url:
+            return self.run(f'remote set-url {self.name} {self.url}')
+
+    def to_dict(self, **kwargs) -> Dict:
+        return dict(
+            name=self.name,
+            project_uuid=self.project.uuid,
+            repo_path=self.repo_path,
+            url=self.url,
+        )
+
+
+@dataclass
+class Branch(BaseVersionControl):
+    name: str = None
+    remote: Remote = None
+
+    def list(self, include_all: bool = False) -> List[str]:
+        commands = ['branch']
+        if include_all:
+            commands.append('-a')
+
+        return self.run(' '.join(commands))
+
+    def create(self):
+        return self.run(f'checkout -b {self.name}')
+
+    def detail(self):
+        return self.run('log')
+
+    def delete(self, name: str = None, force: bool = False):
+        flag = 'd'
+        if force:
+            flag = flag.upper()
+        return self.run(f'branch -{flag} {name or self.name}')
+
+    def update(
+        self,
+        checkout: bool = False,
+        clone: bool = False,
+        merge: bool = False,
+        pull: bool = False,
+        push: bool = False,
+        rebase: bool = False,
+        reset: str = None,
+    ):
+        commands = []
+
+        if clone:
+            commands.append(f'clone -b {self.name}')
+            if self.remote:
+                commands.append(self.remote.url)
+        elif pull or rebase:
+            commands.append('rebase' if rebase else 'pull')
+            if self.remote:
+                commands.append(self.remote.name)
+            commands.append(self.name)
+        elif reset:
+            commands.extend(['reset', reset])
+        elif checkout or merge:
+            commands.extend(['merge' if merge else 'checkout', self.name])
+        elif push:
+            commands.append('push -u')
+            if self.remote:
+                commands.append(self.remote.name)
+            commands.append(self.name)
+
+        return self.run(' '.join(commands))
+
+    def to_dict(self, **kwargs) -> Dict:
+        return dict(
+            name=self.name,
+            project_uuid=self.project.uuid,
+            remote=self.remote.to_dict(**kwargs) if self.remote else None,
+            repo_path=self.repo_path,
+        )
+
+
+@dataclass
+class File(BaseVersionControl):
+    diff: List[str] = None
+    name: str = None
+
+    def list(
+        self,
+        staged: bool = False,     # Modified and git add already
+        unstaged: bool = False,   # Modified but no git add yet
+        untracked: bool = False,  # Modified but never checked in before
+    ) -> str:
+        if staged:
+            return self.run('diff --name-only --staged')
+        elif unstaged:
+            return self.run('diff --name-only')
+        elif untracked:
+            return self.run('ls-files --others --exclude-standard')
+        return self.run('ls-files --other --modified --exclude-standard')
+
+    def create(self):
+        return self.run(f'add {self.name}')
+
+    def detail(self):
+        self.diff = self.run(f'diff {self.name}')
+        return self.diff
+
+    def update(self, add: str = None, commit: str = None, reset: str = False):
+        if add:
+            return self.run(f'add {add}')
+        elif commit:
+            return self.run(f'commit -m "{commit}"')
+        elif reset:
+            return self.run(f'reset {reset}')
+
+    def delete(self):
+        return self.run(f'checkout {self.name}')
+
+    def to_dict(self, **kwargs) -> Dict:
+        return dict(
+            diff=self.diff,
+            name=self.name,
+            project_uuid=self.project.uuid,
+            repo_path=self.repo_path,
+        )
+
+
+@dataclass
+class Project(BaseVersionControl):
+    branch: Branch = None
+    file: File = None
+    remote: Remote = None
+    uuid: str = None
+
+    def __post_init__(self):
+        self.remote = Remote(project=self)
+        self.branch = Branch(project=self)
+        self.branch.remote = self.remote
+        self.file = File(project=self)
+
+    @classmethod
+    def load_all(self) -> List['Project']:
+        settings = (platform_settings() or {}).get('version_control') or {}
+        uuids = list(settings.keys() if settings else [])
+        return [self.load(uuid=uuid) for uuid in uuids]
+
+    @classmethod
+    def create(sefl, uuid: str) -> 'Project':
+        settings = platform_settings() or {}
+        if 'version_control' not in settings:
+            settings['version_control'] = {}
+
+        if uuid not in settings['version_control']:
+            settings['version_control'][uuid] = {}
+            update_settings(settings)
+
+        project = Project.load(uuid=uuid)
+        project.initialize()
+
+        return project
+
+    @property
+    def preferences(self) -> Preferences:
+        return get_preferences(self.repo_path)
+
+    @property
+    def repo_path(self) -> str:
+        return os.path.join(base_repo_path(), self.uuid)
+
+    def exists(self) -> bool:
+        settings = platform_settings() or {}
+        if 'version_control' not in settings:
+            return False
+
+        if self.uuid not in settings['version_control']:
+            return False
+
+        return True
+
+    def to_dict(self, **kwargs) -> Dict:
+        return merge_dict(extract(self.preferences.to_dict(), [
+            'sync_config',
+        ]), dict(
+            repo_path=self.repo_path,
+            uuid=self.uuid,
+        ))
+
+    def initialize(self):
+        if not os.path.exists(self.preferences.preferences_file_path):
+            self.update(dict(
+                sync_config=dict(
+                    repo_path=self.repo_path,
+                ),
+            ))
+
+        git_path = os.path.join(self.repo_path, '.git')
+        if not os.path.exists(git_path):
+            self.run('init')
+
+    def update(self, settings: Dict = None):
+        self.preferences.update_preferences(settings)
+
+    def delete(self):
+        git_path = os.path.join(self.repo_path, '.git')
+        if os.path.exists(git_path):
+            shutil.rmtree(git_path)
+
+        if os.path.exists(self.preferences.preferences_file_path):
+            os.remove(self.preferences.preferences_file_path)
+
+        settings = platform_settings() or {}
+        if 'version_control' in settings and self.uuid in settings.get('version_control'):
+            settings['version_control'].pop(self.uuid, None)
+        update_settings(settings)
+
+    def configure(self, email: str = None, name: str = None):
+        if email:
+            self.run(f'config --global user.email "{email}"')
+        if name:
+            self.run(f'config --global user.name "{name}"')

{mage_ai-0.9.58.dist-info → mage_ai-0.9.59.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mage-ai
-Version: 0.9.58
+Version: 0.9.59
 Summary: Mage is a tool for building and deploying data pipelines.
 Home-page: https://github.com/mage-ai/mage-ai
 Author: Mage
@@ -38,7 +38,7 @@ Requires-Dist: ldap3 ==2.9.1
 Requires-Dist: newrelic ==8.8.0
 Requires-Dist: numpy >=1.21.0
 Requires-Dist: pandas >=1.3.0
-Requires-Dist: polars <=0.19.2
+Requires-Dist: polars <0.19.2,>=0.18.0
 Requires-Dist: protobuf ~=4.21.12
 Requires-Dist: pyarrow-hotfix ==0.5
 Requires-Dist: pyarrow ==10.0.1
@@ -120,10 +120,9 @@ Requires-Dist: psycopg2 ==2.9.3 ; extra == 'all'
 Requires-Dist: pydruid ==0.6.5 ; extra == 'all'
 Requires-Dist: pymongo ==4.3.3 ; extra == 'all'
 Requires-Dist: pyodbc ==4.0.35 ; extra == 'all'
-Requires-Dist: qdrant-client ==1.6.9 ; extra == 'all'
-Requires-Dist: redshift-connector ~=2.0.915 ; extra == 'all'
+Requires-Dist: redshift-connector ==2.0.915 ; extra == 'all'
+Requires-Dist: lxml ==4.9.4 ; extra == 'all'
 Requires-Dist: requests-aws4auth ==1.1.2 ; extra == 'all'
-Requires-Dist: sentence-transformers ==2.2.2 ; extra == 'all'
 Requires-Dist: snowflake-connector-python ==3.2.1 ; extra == 'all'
 Requires-Dist: sshtunnel ==0.4.0 ; extra == 'all'
 Requires-Dist: stomp.py ==8.1.0 ; extra == 'all'
@@ -173,7 +172,8 @@ Requires-Dist: qdrant-client ==1.6.9 ; extra == 'qdrant'
 Requires-Dist: sentence-transformers ==2.2.2 ; extra == 'qdrant'
 Provides-Extra: redshift
 Requires-Dist: boto3 ==1.26.60 ; extra == 'redshift'
-Requires-Dist: redshift-connector ~=2.0.915 ; extra == 'redshift'
+Requires-Dist: redshift-connector ==2.0.915 ; extra == 'redshift'
+Requires-Dist: lxml ==4.9.4 ; extra == 'redshift'
 Provides-Extra: s3
 Requires-Dist: boto3 ==1.26.60 ; extra == 's3'
 Requires-Dist: botocore ==1.29.60 ; extra == 's3'