PyS3Uploader 0.2.0__py3-none-any.whl → 0.4.0a1__py3-none-any.whl

pys3uploader/utils.py

@@ -0,0 +1,194 @@
+import math
+import os
+from typing import Dict, Set, List
+
+from botocore.config import Config
+
+RETRY_CONFIG: Config = Config(
+    retries={
+        "max_attempts": 10,
+        "mode": "adaptive",  # Adaptive retry mode with jitter
+        "total_max_attempts": 20,  # Max retries across all requests
+    },
+    # Adding custom timeouts here:
+    connect_timeout=5,  # 5 seconds for establishing a connection
+    read_timeout=30,  # 30 seconds to wait for a response from the server
+)
+
+
+class UploadResults(dict):
+    """Object to store results of S3 upload.
+
+    >>> UploadResults
+
+    """
+
+    success: List[str] = []
+    failed: List[str] = []
+
+
+def getenv(*args, default: str = None) -> str:
+    """Returns the key-ed environment variable or the default value.
+
+    Args:
+        args: Environment variable keys to search for.
+        default: Default value to return if no environment variable is found.
+
+    Returns:
+        str:
+        Environment variable value or the default value.
+    """
+    for key in args:
+        if value := os.environ.get(key.upper()) or os.environ.get(key.lower()):
+            return value
+    return default
+
+
+def urljoin(*args) -> str:
+    """Joins given arguments into a url. Trailing but not leading slashes are stripped for each argument.
+
+    Args:
+        args: Parts of the url to join.
+
+    Returns:
+        str:
+        Joined url.
+    """
+    return "/".join(map(lambda x: str(x).rstrip("/").lstrip("/"), args))
+
+
+def convert_to_folder_structure(sequence: Set[str]) -> str:
+    """Convert objects in a s3 buckets into a folder like representation.
+
+    Args:
+        sequence: Takes either a mutable or immutable sequence as an argument.
+
+    Returns:
+        str:
+        String representation of the architecture.
+    """
+    folder_structure = {}
+    for item in sequence:
+        parts = item.split("/")
+        current_level = folder_structure
+        for part in parts:
+            current_level = current_level.setdefault(part, {})
+
+    def generate_folder_structure(structure: Dict[str, dict], indent: str = "") -> str:
+        """Generates the folder like structure.
+
+        Args:
+            structure: Structure of folder objects as key-value pairs.
+            indent: Required indentation for the ASCII.
+
+        Returns:
+            str:
+            String representation of the folder structure.
+        """
+        result = ""
+        for i, (key, value) in enumerate(structure.items()):
+            if i == len(structure) - 1:
+                result += indent + "└── " + key + "\n"
+                sub_indent = indent + "    "
+            else:
+                result += indent + "├── " + key + "\n"
+                sub_indent = indent + "│   "
+            if value:
+                result += generate_folder_structure(value, sub_indent)
+        return result
+
+    return generate_folder_structure(folder_structure)
+
+
+def convert_seconds(seconds: int | float, n_elem: int = 2) -> str:
+    """Calculate years, months, days, hours, minutes, seconds, and milliseconds from given input.
+
+    Args:
+        seconds: Number of seconds to convert (supports float values).
+        n_elem: Number of elements required from the converted list.
+
+    Returns:
+        str:
+        Returns a humanized string notion of the number of seconds.
+    """
+    if not seconds:
+        return "0s"
+    elif seconds < 1:
+        return f"{seconds * 1000:.0f}ms"
+
+    seconds_in_year = 365 * 24 * 3600
+    seconds_in_month = 30 * 24 * 3600
+
+    years = seconds // seconds_in_year
+    seconds %= seconds_in_year
+
+    months = seconds // seconds_in_month
+    seconds %= seconds_in_month
+
+    days = seconds // (24 * 3600)
+    seconds %= 24 * 3600
+
+    hours = seconds // 3600
+    seconds %= 3600
+
+    minutes = seconds // 60
+    seconds %= 60
+
+    milliseconds = round((seconds % 1) * 1000)
+    seconds = int(seconds)  # Convert remaining seconds to int for display
+
+    time_parts = []
+
+    if years > 0:
+        time_parts.append(f"{int(years)} year{'s' if years > 1 else ''}")
+    if months > 0:
+        time_parts.append(f"{int(months)} month{'s' if months > 1 else ''}")
+    if days > 0:
+        time_parts.append(f"{int(days)} day{'s' if days > 1 else ''}")
+    if hours > 0:
+        time_parts.append(f"{int(hours)} hour{'s' if hours > 1 else ''}")
+    if minutes > 0:
+        time_parts.append(f"{int(minutes)} minute{'s' if minutes > 1 else ''}")
+    if seconds > 0 or milliseconds > 0:
+        if seconds > 0 and milliseconds > 0:
+            time_parts.append(f"{seconds + milliseconds / 1000:.1f}s")
+        elif seconds > 0:
+            time_parts.append(f"{seconds}s")
+        else:
+            time_parts.append(f"{milliseconds}ms")
+
+    if len(time_parts) == 1:
+        return time_parts[0]
+
+    list_ = time_parts[:n_elem]
+    return ", and ".join([", ".join(list_[:-1]), list_[-1]] if len(list_) > 2 else list_)
+
+
+def format_nos(input_: float) -> int | float:
+    """Removes ``.0`` float values.
+
+    Args:
+        input_: Strings or integers with ``.0`` at the end.
+
+    Returns:
+        int | float:
+        Int if found, else returns the received float value.
+    """
+    return int(input_) if isinstance(input_, float) and input_.is_integer() else input_
+
+
+def size_converter(byte_size: int | float) -> str:
+    """Gets the current memory consumed and converts it to human friendly format.
+
+    Args:
+        byte_size: Receives byte size as argument.
+
+    Returns:
+        str:
+        Converted understandable size.
+    """
+    if not byte_size:
+        return "0 B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    index = int(math.floor(math.log(byte_size, 1024)))
+    return f"{format_nos(round(byte_size / pow(1024, index), 2))} {size_name[index]}"

pys3uploader/version.py

@@ -0,0 +1 @@
+version = "0.4.0a1"

{pys3uploader-0.2.0.dist-info → pys3uploader-0.4.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyS3Uploader
-Version: 0.2.0
+Version: 0.4.0a1
 Summary: Python module to upload objects to an S3 bucket.
 Author-email: Vignesh Rao <svignesh1793@gmail.com>
 License: MIT License
@@ -29,7 +29,7 @@ Project-URL: Homepage, https://github.com/thevickypedia/PyS3Uploader
 Project-URL: Docs, https://thevickypedia.github.io/PyS3Uploader/
 Project-URL: Source, https://github.com/thevickypedia/PyS3Uploader
 Project-URL: Bug Tracker, https://github.com/thevickypedia/PyS3Uploader/issues
-Keywords: s3
+Keywords: pys3uploader
 Classifier: Development Status :: 1 - Planning
 Classifier: Intended Audience :: Information Technology
 Classifier: Operating System :: OS Independent
@@ -39,8 +39,9 @@ Classifier: Topic :: Internet :: File Transfer Protocol (FTP)
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: alive-progress==3.3.*
 Requires-Dist: boto3==1.40.*
-Requires-Dist: tqdm==4.67.*
+Requires-Dist: python-dotenv==1.1.*
 Provides-Extra: dev
 Requires-Dist: sphinx==5.1.1; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
@@ -75,6 +76,43 @@ Requires-Dist: recommonmark; extra == "dev"
 # PyS3Uploader
 Python module to upload an entire directory to an S3 bucket.
 
+<details>
+<summary><strong>Bucket Policy Required</strong></summary>
+
+```json
+{
+    "Version": "2012-10-17",
+    "Statement": [
+        {
+            "Sid": "ListBucketsForExistenceCheck",
+            "Effect": "Allow",
+            "Action": "s3:ListAllMyBuckets",
+            "Resource": "*"
+        },
+        {
+            "Sid": "ListAndUploadToSpecificBucket",
+            "Effect": "Allow",
+            "Action": [
+                "s3:ListBucket",
+                "s3:ListBucketMultipartUploads"
+            ],
+            "Resource": "arn:aws:s3:::bucketname"
+        },
+        {
+            "Sid": "UploadObjectsToBucket",
+            "Effect": "Allow",
+            "Action": [
+                "s3:PutObject",
+                "s3:AbortMultipartUpload",
+                "s3:ListMultipartUploadParts"
+            ],
+            "Resource": "arn:aws:s3:::bucketname/*"
+        }
+    ]
+}
+```
+</details>
+
 ### Installation
 ```shell
 pip install PyS3Uploader
@@ -84,26 +122,26 @@ pip install PyS3Uploader
 
 ##### Upload objects in parallel
 ```python
-import s3
+import pys3uploader
 
 if __name__ == '__main__':
-    wrapper = s3.Uploader(
+    wrapper = pys3uploader.Uploader(
         bucket_name="BUCKET_NAME",
         upload_dir="FULL_PATH_TO_UPLOAD",
-        exclude_path="PART_OF_UPLOAD_DIR_TO_EXCLUDE"
+        exclude_prefix="PART_OF_UPLOAD_DIR_TO_EXCLUDE"
     )
     wrapper.run_in_parallel()
 ```
 
 ##### Upload objects in sequence
 ```python
-import s3
+import pys3uploader
 
 if __name__ == '__main__':
-    wrapper = s3.Uploader(
+    wrapper = pys3uploader.Uploader(
         bucket_name="BUCKET_NAME",
         upload_dir="FULL_PATH_TO_UPLOAD",
-        exclude_path="PART_OF_UPLOAD_DIR_TO_EXCLUDE"
+        exclude_prefix="PART_OF_UPLOAD_DIR_TO_EXCLUDE"
     )
     wrapper.run()
 ```
@@ -114,8 +152,15 @@ if __name__ == '__main__':
 
 #### Optional kwargs
 - **s3_prefix** - S3 object prefix for each file. Defaults to ``None``
-- **exclude_path** - Path in ``upload_dir`` that has to be excluded in object keys. Defaults to `None`
+- **exclude_prefix** - Path in ``upload_dir`` that has to be excluded in object keys. Defaults to `None`
+- **skip_dot_files** - Boolean flag to skip dot files. Defaults to ``True``
+- **overwrite** - Boolean flag to overwrite files present in S3. Defaults to ``False``
+- **file_exclusion** - Sequence of files to exclude during upload. Defaults to ``None``
+- **folder_exclusion** - Sequence of directories to exclude during upload. Defaults to ``None``
 - **logger** - Bring your own custom pre-configured logger. Defaults to on-screen logging.
+- **log_handler** - Choose between `stdout` vs `file` logging. Defaults to `pys3uploader.LogHandler.stdout`
+- **log_level** - Choose the logging level. Defaults to `pys3uploader.LogLevel.debug`
+- **env_file** – Path to a `.env` file for loading environment variables. Defaults to scanning the current directory.
 <br><br>
 - **region_name** - AWS region name. Defaults to the env var `AWS_DEFAULT_REGION`
 - **profile_name** - AWS profile name. Defaults to the env var `PROFILE_NAME`

pys3uploader-0.4.0a1.dist-info/RECORD

@@ -0,0 +1,15 @@
+pys3uploader/__init__.py,sha256=EqMScWbJNV4UWeMg4fMko2KB18xL2CO3a3o_od0H0Lc,124
+pys3uploader/exceptions.py,sha256=hH3jlMOe8yjBatQK9EdndWZz4QESU74KSY_iDhQ37SY,2585
+pys3uploader/logger.py,sha256=z9JEnyf4nHIakey0bAaCgEN7oXOYJYOpskZyM_4s-D4,2678
+pys3uploader/metadata.py,sha256=tOOoLh2vISfH-GfH3yBcA_xtEjRwomaw7sCLEaDRK-8,230
+pys3uploader/progress.py,sha256=IladNMXLBhkPpxOntpANTam_hC9OWosmNDmdbweDNYM,1195
+pys3uploader/timer.py,sha256=qN2XNrGEyP3stsK3McvhE3VvIiUFh7mv4rbp5WDeyVU,1498
+pys3uploader/tree.py,sha256=DiQ2ekMMaj2m_P3-iKkEqSuJCJZ_UZxcAwHtAoPVa5c,1824
+pys3uploader/uploader.py,sha256=h5DYQA2yv0fQ2SSyAnAl8SsgJUajmN_o1PdMSqMbACM,18588
+pys3uploader/utils.py,sha256=_2RYKUTyrQzwkxo7fSiLb5ASrpjcNpb3kZHqy_wByRk,5755
+pys3uploader/version.py,sha256=VAwBBgd_skAqJS9UL1T_xDXryTqN5m58fbTTEXcKxgM,20
+pys3uploader-0.4.0a1.dist-info/LICENSE,sha256=8k-hEraOzyum0GvmmK65YxNRTFXK7eIFHJ0OshJXeTk,1068
+pys3uploader-0.4.0a1.dist-info/METADATA,sha256=FdJdNSesnP1xHfb4il5HBw1pxsPn7ToAYkQ_T3PrIb0,8959
+pys3uploader-0.4.0a1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+pys3uploader-0.4.0a1.dist-info/top_level.txt,sha256=lVIFMMoUx7dj_myetBmOUQTJiOzz5VyDqchnQElmrWw,13
+pys3uploader-0.4.0a1.dist-info/RECORD,,

pys3uploader-0.4.0a1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pys3uploader

pys3uploader-0.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-s3/__init__.py,sha256=yLvvl4-uTLZwhdhCMQpWq5juX_zFuYAfKSf4aB0WjZw,66
-s3/exceptions.py,sha256=hH3jlMOe8yjBatQK9EdndWZz4QESU74KSY_iDhQ37SY,2585
-s3/logger.py,sha256=oH540oq8jY723jA4lDWlgfFPLbNgGXTkDwFpB7TLO_o,1196
-s3/tree.py,sha256=DiQ2ekMMaj2m_P3-iKkEqSuJCJZ_UZxcAwHtAoPVa5c,1824
-s3/uploader.py,sha256=IAlFrEjfBuexrfmBPGN9OZAfHjQuwcGRzWi2es0r_fU,11154
-s3/utils.py,sha256=0kcG0aE2olHhC8thaUEwx2J8tOI2-2TGCk6E6U-PiKw,2058
-pys3uploader-0.2.0.dist-info/LICENSE,sha256=8k-hEraOzyum0GvmmK65YxNRTFXK7eIFHJ0OshJXeTk,1068
-pys3uploader-0.2.0.dist-info/METADATA,sha256=IXSmHXJJndlnd_6MHlpZrcVILPni8VUbVNJYQEjMIR8,7286
-pys3uploader-0.2.0.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-pys3uploader-0.2.0.dist-info/top_level.txt,sha256=iQp4y1P58Q633gj8M08kHE4mqqT0hixuDWcniDk_RJ4,3
-pys3uploader-0.2.0.dist-info/RECORD,,

pys3uploader-0.2.0.dist-info/top_level.txt

@@ -1 +0,0 @@
-s3

s3/__init__.py

@@ -1,3 +0,0 @@
-from s3.uploader import Uploader  # noqa: F401
-
-version = "0.2.0"

s3/logger.py

@@ -1,45 +0,0 @@
-"""Loads a default logger with StreamHandler set to DEBUG mode.
-
->>> logging.Logger
-
-"""
-
-import logging
-
-
-def default_handler() -> logging.StreamHandler:
-    """Creates a ``StreamHandler`` and assigns a default format to it.
-
-    Returns:
-        logging.StreamHandler:
-        Returns an instance of the ``StreamHandler`` object.
-    """
-    handler = logging.StreamHandler()
-    handler.setFormatter(fmt=default_format())
-    return handler
-
-
-def default_format() -> logging.Formatter:
-    """Creates a logging ``Formatter`` with a custom message and datetime format.
-
-    Returns:
-        logging.Formatter:
-        Returns an instance of the ``Formatter`` object.
-    """
-    return logging.Formatter(
-        fmt="%(asctime)s - %(levelname)s - [%(module)s:%(lineno)d] - %(funcName)s - %(message)s",
-        datefmt="%b-%d-%Y %I:%M:%S %p",
-    )
-
-
-def default_logger() -> logging.Logger:
-    """Creates a default logger with debug mode enabled.
-
-    Returns:
-        logging.Logger:
-        Returns an instance of the ``Logger`` object.
-    """
-    logger = logging.getLogger(__name__)
-    logger.addHandler(hdlr=default_handler())
-    logger.setLevel(level=logging.DEBUG)
-    return logger

s3/uploader.py

@@ -1,264 +0,0 @@
-import logging
-import os
-import time
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Dict
-
-import boto3.resources.factory
-from botocore.config import Config
-from botocore.exceptions import ClientError
-from tqdm import tqdm
-
-from s3.exceptions import BucketNotFound
-from s3.logger import default_logger
-from s3.utils import UploadResults, convert_to_folder_structure, getenv, urljoin
-
-
-class Uploader:
-    """Initiates Uploader object to upload entire directory to S3.
-
-    >>> Uploader
-
-    """
-
-    RETRY_CONFIG: Config = Config(retries={"max_attempts": 10, "mode": "standard"})
-
-    def __init__(
-        self,
-        bucket_name: str,
-        upload_dir: str,
-        s3_prefix: str = None,
-        exclude_path: str = None,
-        overwrite: bool = False,
-        region_name: str = None,
-        profile_name: str = None,
-        aws_access_key_id: str = None,
-        aws_secret_access_key: str = None,
-        logger: logging.Logger = None,
-    ):
-        """Initiates all the necessary args and creates a boto3 session with retry logic.
-
-        Args:
-            bucket_name: Name of the bucket.
-            upload_dir: Full path of the directory to be uploaded.
-            s3_prefix: Particular bucket prefix within which the upload should happen.
-            exclude_path: Full directory path to exclude from S3 object prefix.
-            overwrite: Boolean flag to overwrite files in S3.
-            region_name: Name of the AWS region.
-            profile_name: AWS profile name.
-            aws_access_key_id: AWS access key ID.
-            aws_secret_access_key: AWS secret access key.
-            logger: Bring your own logger.
-
-        See Also:
-            exclude_path:
-                When upload directory is "/home/ubuntu/Desktop/S3Upload", each file will naturally have the full prefix.
-                However, this behavior can be avoided by specifying the ``exclude_path`` parameter.
-
-                If exclude_path is set to: ``/home/ubuntu/Desktop``, then the file path
-                ``/home/ubuntu/Desktop/S3Upload/sub-dir/photo.jpg`` will be uploaded as ``S3Upload/sub-dir/photo.jpg``
-
-            s3_prefix:
-                If provided, ``s3_prefix`` will always be attached to each object.
-
-                If ``s3_prefix`` is set to: ``2025``, then the file path
-                ``/home/ubuntu/Desktop/S3Upload/sub/photo.jpg`` will be uploaded as ``2025/S3Upload/sub/photo.jpg``
-        """
-        self.session = boto3.Session(
-            profile_name=profile_name or getenv("PROFILE_NAME"),
-            region_name=region_name or getenv("AWS_DEFAULT_REGION"),
-            aws_access_key_id=aws_access_key_id or getenv("AWS_ACCESS_KEY_ID"),
-            aws_secret_access_key=aws_secret_access_key or getenv("AWS_SECRET_ACCESS_KEY"),
-        )
-        self.s3 = self.session.resource(service_name="s3", config=self.RETRY_CONFIG)
-
-        self.logger = logger or default_logger()
-
-        self.bucket_name = bucket_name
-        self.upload_dir = upload_dir or getenv("UPLOAD_DIR", "UPLOAD_SOURCE")
-        self.s3_prefix = s3_prefix
-        self.exclude_path = exclude_path
-        self.overwrite = overwrite
-
-        self.results = UploadResults()
-        self.start = time.time()
-
-        # noinspection PyUnresolvedReferences
-        self.bucket: boto3.resources.factory.s3.Bucket = None
-        # noinspection PyUnresolvedReferences
-        self.bucket_objects: boto3.resources.factory.s3.ObjectSummary = []
-        self.object_size_map: Dict[str, int] = {}
-
-    def init(self) -> None:
-        """Instantiates the bucket instance.
-
-        Raises:
-            ValueError: If no bucket name was passed.
-            BucketNotFound: If bucket name was not found.
-        """
-        self.start = time.time()
-        if self.exclude_path and self.exclude_path not in self.upload_dir:
-            raise ValueError(
-                f"\n\n\tStart folder {self.exclude_path!r} is not a part of upload directory {self.upload_dir!r}"
-            )
-        if not self.upload_dir:
-            raise ValueError("\n\n\tCannot proceed without an upload directory.")
-        try:
-            assert os.path.exists(self.upload_dir)
-        except AssertionError:
-            raise ValueError(f"\n\n\tPath not found: {self.upload_dir}")
-        buckets = [bucket.name for bucket in self.s3.buckets.all()]
-        if not self.bucket_name:
-            raise ValueError(f"\n\n\tCannot proceed without a bucket name.\n\tAvailable: {buckets}")
-        _account_id, _alias = self.session.resource(service_name="iam").CurrentUser().arn.split("/")
-        if self.bucket_name not in buckets:
-            raise BucketNotFound(f"\n\n\t{self.bucket_name} was not found in {_alias} account.\n\tAvailable: {buckets}")
-        self.upload_dir = os.path.abspath(self.upload_dir)
-        # noinspection PyUnresolvedReferences
-        self.bucket: boto3.resources.factory.s3.Bucket = self.s3.Bucket(self.bucket_name)
-        # noinspection PyUnresolvedReferences
-        self.bucket_objects: boto3.resources.factory.s3.ObjectSummary = [obj for obj in self.bucket.objects.all()]
-        self.object_size_map = {obj.key: obj.size for obj in self.bucket_objects}
-
-    def exit(self) -> None:
-        """Exits after printing results, and run time."""
-        total = self.results.success + self.results.failed
-        self.logger.info(
-            "Total number of uploads: %d, success: %d, failed: %d", total, self.results.success, self.results.failed
-        )
-        self.logger.info("Run Time: %.2fs", time.time() - self.start)
-
-    def _proceed_to_upload(self, filepath: str, objectpath: str) -> bool:
-        """Compares file size if the object already exists in S3.
-
-        Args:
-            filepath: Source filepath.
-            objectpath: S3 object path.
-
-        Returns:
-            bool:
-            Returns a boolean flag to indicate upload flag.
-        """
-        if self.overwrite:
-            return True
-        # Indicates that the object path already exists in S3
-        if object_size := self.object_size_map.get(objectpath):
-            try:
-                file_size = os.path.getsize(filepath)
-            except (OSError, PermissionError) as error:
-                self.logger.error(error)
-                return True
-            if object_size == file_size:
-                self.logger.info("S3 object %s exists, and size [%d] matches, skipping..", objectpath, object_size)
-                return False
-            self.logger.info(
-                "S3 object %s exists, but size mismatch. Local: [%d], S3: [%d]", objectpath, file_size, object_size
-            )
-        return True
-
-    def _uploader(self, filepath: str, objectpath: str) -> None:
-        """Uploads the filepath to the specified S3 bucket.
-
-        Args:
-            filepath: Filepath to upload.
-            objectpath: Object path ref in S3.
-        """
-        if self._proceed_to_upload(filepath, objectpath):
-            self.bucket.upload_file(filepath, objectpath)
-
-    def _get_files(self) -> Dict[str, str]:
-        """Get a mapping for all the file path and object paths in upload directory.
-
-        Returns:
-            Dict[str, str]:
-            Returns a key-value pair of filepath and objectpath.
-        """
-        files_to_upload = {}
-        for __path, __directory, __files in os.walk(self.upload_dir):
-            for file_ in __files:
-                file_path = os.path.join(__path, file_)
-                if self.exclude_path:
-                    relative_path = file_path.replace(self.exclude_path, "")
-                else:
-                    relative_path = file_path
-                # Lists in python are ordered, so s3 prefix will get loaded first when provided
-                url_parts = []
-                if self.s3_prefix:
-                    url_parts.extend(
-                        self.s3_prefix.split(os.sep) if os.sep in self.s3_prefix else self.s3_prefix.split("/")
-                    )
-                # Add rest of the file path to parts before normalizing as an S3 object URL
-                url_parts.extend(relative_path.split(os.sep))
-                # Remove falsy values using filter - "None", "bool", "len" or "lambda item: item"
-                object_path = urljoin(*filter(None, url_parts))
-                files_to_upload[file_path] = object_path
-        return files_to_upload
-
-    def run(self) -> None:
-        """Initiates object upload in a traditional loop."""
-        self.init()
-        keys = self._get_files()
-        self.logger.debug(keys)
-        self.logger.info("%d files from '%s' will be uploaded to '%s'", len(keys), self.upload_dir, self.bucket_name)
-        self.logger.info("Initiating upload process.")
-        for objectpath, filepath in tqdm(
-            keys.items(), total=len(keys), unit="file", leave=True, desc=f"Uploading files from {self.upload_dir}"
-        ):
-            try:
-                self._uploader(filepath=filepath, objectpath=objectpath)
-                self.results.success += 1
-            except ClientError as error:
-                self.logger.error(error)
-                self.results.failed += 1
-        self.exit()
-
-    def run_in_parallel(self, max_workers: int = 5) -> None:
-        """Initiates upload in multi-threading.
-
-        Args:
-            max_workers: Number of maximum threads to use.
-        """
-        self.init()
-        keys = self._get_files()
-        self.logger.debug(keys)
-        self.logger.info(
-            "%d files from '%s' will be uploaded to '%s' with maximum concurrency of: %d",
-            len(keys),
-            self.upload_dir,
-            self.bucket_name,
-            max_workers,
-        )
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            futures = [
-                executor.submit(self._uploader, **dict(filepath=filepath, objectpath=objectpath))
-                for filepath, objectpath in keys.items()
-            ]
-            for future in tqdm(
-                iterable=as_completed(futures),
-                total=len(futures),
-                desc=f"Uploading files to {self.bucket_name}",
-                unit="files",
-                leave=True,
-            ):
-                try:
-                    future.result()
-                    self.results.success += 1
-                except ClientError as error:
-                    self.logger.error(f"Upload failed: {error}")
-                    self.results.failed += 1
-        self.exit()
-
-    def get_bucket_structure(self) -> str:
-        """Gets all the objects in an S3 bucket and forms it into a hierarchical folder like representation.
-
-        Returns:
-            str:
-            Returns a hierarchical folder like representation of the chosen bucket.
-        """
-        self.init()
-        # Using list and set will yield the same results but using set we can isolate directories from files
-        return convert_to_folder_structure(set(obj.key for obj in self.bucket_objects))
-
-    def print_bucket_structure(self) -> None:
-        """Prints all the objects in an S3 bucket with a folder like representation."""
-        print(self.get_bucket_structure())