primitive 0.1.68__py3-none-any.whl → 0.1.69__py3-none-any.whl

primitive/files/actions.py

@@ -1,3 +1,4 @@
+import concurrent
 import hashlib
 import sys
 import threading
@@ -11,11 +12,15 @@ from loguru import logger
 from primitive.graphql.sdk import create_requests_session
 from primitive.utils.actions import BaseAction
 
-from ..utils.auth import guard
+from ..utils.auth import create_new_session, guard
+from ..utils.chunk_size import calculate_optimal_chunk_size, get_upload_speed_mb
+from ..utils.memory_size import MemorySize
 from .graphql.mutations import (
     file_update_mutation,
     pending_file_create_mutation,
+    update_parts_details,
 )
+from .graphql.queries import files_list
 
 
 # this class can be used in multithreaded S3 client uploader
@@ -41,6 +46,12 @@ class ProgressPercentage(object):
 
 
 class Files(BaseAction):
+    def __init__(self, primitive):
+        super().__init__(primitive)
+        self.num_workers = 4
+        self.upload_speed_mbps = None
+        self.upload_speed_mbps = "100"
+
     def _pending_file_create(
         self,
         file_name: str,
@@ -48,6 +59,8 @@ class Files(BaseAction):
         file_checksum: str,
         file_path: str,
         key_prefix: str,
+        chunk_size: int,
+        number_of_parts: int,
         is_public: bool = False,
     ):
         mutation = gql(pending_file_create_mutation)
@@ -58,6 +71,8 @@ class Files(BaseAction):
             "fileChecksum": file_checksum,
             "keyPrefix": key_prefix,
             "isPublic": is_public,
+            "chunkSize": chunk_size,
+            "numberOfParts": number_of_parts,
         }
         variables = {"input": input}
         result = self.primitive.session.execute(
@@ -86,11 +101,102 @@ class Files(BaseAction):
         )
         return result
 
+    def _update_parts_details(
+        self,
+        file_id: str,
+        part_number: int,
+        etag: str,
+    ):
+        mutation = gql(update_parts_details)
+        input = {
+            "fileId": file_id,
+            "partNumber": part_number,
+            "etag": etag,
+        }
+        variables = {"input": input}
+
+        # since this is called in a multithreaded environment,
+        # we need to create a new session for each thread.
+        session = create_new_session(self.primitive)
+        result = session.execute(
+            mutation, variable_values=variables, get_execution_result=True
+        )
+        return result
+
+    @guard
+    def get_file(self, file_id: Optional[str] = None):
+        query = gql(files_list)
+
+        filters = {}
+        if file_id:
+            filters["id"] = {"exact": file_id}
+
+        variables = {
+            "first": 1,
+            "filters": filters,
+        }
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
+        return result
+
+    def _upload_part(
+        self,
+        file_id: str,
+        file_path: Path,
+        part_number: int,
+        presigned_url: str,
+        start_byte: int,
+        end_byte: int,
+    ):
+        part_data = None
+        with open(file_path, "rb") as file:
+            file.seek(start_byte)
+            part_data = file.read(end_byte - start_byte)
+            assert len(part_data) > 0
+            file.seek(0)
+        logger.debug(
+            f"Part {part_number}. Start: {start_byte}. End: {end_byte}. Size: {len(part_data)}"
+        )
+
+        md5_hexdigest = hashlib.md5(part_data).hexdigest()  # Get raw MD5 bytes
+
+        logger.debug(f"Uploading part {part_number}...")
+        # Upload the part using the pre-signed URL
+        response = requests.put(
+            presigned_url,
+            data=part_data,
+        )
+        # cleanup memory
+        part_data = None
+
+        if response.ok:
+            # Extract the ETag for the part from the response headers
+            etag = response.headers.get("ETag").replace('"', "")
+            if not etag:
+                logger.error("Failed to retrieve ETag from response headers")
+        else:
+            logger.error(response.text)
+            response.raise_for_status()
+
+        if etag != md5_hexdigest:
+            message = f"Part {part_number} ETag does not match MD5 checksum: {etag} != {md5_hexdigest}"
+            logger.error(message)
+            raise Exception(message)
+
+        if etag:
+            return self._update_parts_details(
+                file_id, part_number=part_number, etag=etag
+            )
+        else:
+            logger.error(f"Failed to upload part {part_number}")
+            return None
+
     @guard
     def upload_file_direct(
         self,
         path: Path,
-        is_public: False,
+        is_public: bool = False,
         key_prefix: str = "",
         file_id: Optional[str] = None,
     ):
@@ -104,7 +210,26 @@ class Files(BaseAction):
 
         file_checksum = hashlib.md5(path.read_bytes()).hexdigest()
 
+        parts_details = None
+
+        if not self.upload_speed_mbps:
+            logger.info("Calculating upload speed...")
+            self.upload_speed_mbps = get_upload_speed_mb()
+            logger.info(f"Upload speed: {self.upload_speed_mbps} MB/s")
+
         if not file_id:
+            chunk_size, number_of_parts = calculate_optimal_chunk_size(
+                upload_speed_mb=self.upload_speed_mbps,
+                file_size_bytes=file_size,
+                num_workers=self.num_workers,
+                optimal_time_seconds=5,
+            )
+            chunk_size_ms = MemorySize(chunk_size, "B")
+            chunk_size_ms.convert_to("MB")
+            logger.info(
+                f"Creating Pending File for {path}. File Size: {MemorySize(file_size, "B").get_human_readable()} ({file_size}). Chunk size: {chunk_size_ms} at Number of parts: {number_of_parts}"
+            )
+
             pending_file_create = self._pending_file_create(
                 file_name=path.name,
                 file_size=path.stat().st_size,
@@ -112,34 +237,71 @@ class Files(BaseAction):
                 file_path=str(path),
                 key_prefix=key_prefix,
                 is_public=is_public,
+                chunk_size=chunk_size,
+                number_of_parts=number_of_parts,
+            )
+            file_id = pending_file_create.get("id")
+            parts_details = pending_file_create.get("partsDetails")
+        else:
+            get_file_result = self.get_file(file_id)
+            parts_details = (
+                get_file_result.data.get("files")
+                .get("edges")[0]
+                .get("node")
+                .get("partsDetails")
             )
-        file_id = pending_file_create.get("id")
-        presigned_url = pending_file_create.get("presignedUrlForUpload")
 
         if not file_id:
             raise Exception("No file_id found or provided.")
-        if not presigned_url:
-            raise Exception("No presigned_url returned.")
+        if not parts_details:
+            raise Exception(f"No parts_details returned for File ID: {file_id}.")
 
         self._update_file_status(file_id, is_uploading=True)
-        with open(path, "rb") as object_file:
-            object_text = object_file.read()
-            response = requests.put(presigned_url, data=object_text)
-            if response.ok:
-                logger.info(f"File {path} uploaded successfully.")
-                update_file_status_result = self._update_file_status(
-                    file_id, is_uploading=False, is_complete=True
-                )
-            else:
-                message = f"Failed to upload file {path}. {response.status_code}: {response.text}"
-                logger.error(message)
-                raise Exception(message)
-        file_pk = update_file_status_result.data.get("fileUpdate").get("pk")
-        transport = self.primitive.host_config.get("transport")
-        host = self.primitive.host_config.get("host")
-        file_access_url = f"{transport}://{host}/files/{file_pk}/presigned-url/"
-        logger.info(f"Available at: {file_access_url}")
-        return update_file_status_result
+
+        # now create a multithreaded uploader based on the number of cores available
+        # each thread will read from its starting and ending byte range provided by parts_details
+        # and upload that part to the presigned url
+        # an ETag will be returned for each part uploaded and will need to stored in the parts_details
+        # on the server side by updating the File object
+
+        is_complete = True
+
+        # Upload parts in parallel
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=self.num_workers
+        ) as executor:
+            future_to_part = {
+                executor.submit(
+                    self._upload_part,
+                    file_id=file_id,
+                    file_path=path,
+                    part_number=part_details.get("PartNumber"),
+                    presigned_url=part_details.get("presigned_url"),
+                    start_byte=part_details.get("start_byte"),
+                    end_byte=part_details.get("end_byte"),
+                ): part_details
+                for _key, part_details in parts_details.items()
+            }
+            for future in concurrent.futures.as_completed(future_to_part):
+                part_detail = future_to_part[future]
+                try:
+                    future.result()
+                    logger.debug(
+                        f"Part {part_detail.get('PartNumber')} uploaded successfully."
+                    )
+                except Exception as exception:
+                    logger.error(
+                        f"Part {part_detail.get('PartNumber')} generated an exception: {exception}"
+                    )
+                    is_complete = False
+
+        # when all parts have ETags (updated), send an update that
+        if is_complete:
+            update_file_status_result = self._update_file_status(
+                file_id, is_uploading=False, is_complete=True
+            )
+            logger.info(f"File {path} marked is_complete.")
+            return update_file_status_result
 
     @guard
     def upload_file_via_api(
@@ -147,7 +309,6 @@ class Files(BaseAction):
         path: Path,
         is_public: bool = False,
         key_prefix: str = "",
-        job_run_id: str = "",
     ):
         """
         This method uploads a file via the Primitive API.
@@ -163,8 +324,6 @@ class Files(BaseAction):
                 + file_path
                 + """\", "keyPrefix": \""""
                 + key_prefix
-                + """\", "jobRunId": \""""
-                + job_run_id
                 + """\" } } }"""
             )  # noqa
 
@@ -174,8 +333,6 @@ class Files(BaseAction):
                 + file_path
                 + """\", "keyPrefix": \""""
                 + key_prefix
-                + """\", "jobRunId": \""""
-                + job_run_id
                 + """\" } } }"""
             )  # noqa
         body = {
@@ -189,3 +346,9 @@ class Files(BaseAction):
         url = f"{transport}://{self.primitive.host}/"
         response = session.post(url, files=body)
         return response
+
+    def get_presigned_url(self, file_pk: str):
+        transport = self.primitive.host_config.get("transport")
+        host = self.primitive.host_config.get("host")
+        file_access_url = f"{transport}://{host}/files/{file_pk}/presigned-url/"
+        return file_access_url

primitive/files/commands.py

@@ -35,6 +35,9 @@ def file_upload_command(context, path, public, key_prefix, direct):
         result = primitive.files.upload_file_via_api(
             path, is_public=public, key_prefix=key_prefix
         )
+    try:
+        message = json.dumps(result.data)
+    except AttributeError:
+        message = "File Upload Failed"
 
-    message = json.dumps(result.data)
     print_result(message=message, context=context)

primitive/files/graphql/fragments.py

@@ -0,0 +1,18 @@
+file_fragment = """
+fragment FileFragment on File {
+  id
+  pk
+  createdAt
+  updatedAt
+  createdBy
+  location
+  fileName
+  fileSize
+  fileChecksum
+  isUploading
+  isComplete
+  partsDetails
+  humanReadableMemorySize
+  contents
+}
+"""

primitive/files/graphql/mutations.py

@@ -23,7 +23,23 @@ mutation pendingFileCreate($input: PendingFileCreateInput!) {
         ... on File {
             id
             pk
-            presignedUrlForUpload
+            partsDetails
+        }
+        ...OperationInfoFragment
+    }
+}
+"""
+)
+
+update_parts_details = (
+    operation_info_fragment
+    + """
+mutation updatePartsDetails($input: UpdatePartsDetailsInput!) {
+    updatePartsDetails(input: $input) {
+        ... on File {
+            id
+            pk
+            partsDetails
         }
         ...OperationInfoFragment
     }

primitive/files/graphql/queries.py

@@ -0,0 +1,31 @@
+from .fragments import file_fragment
+
+files_list = (
+    file_fragment
+    + """
+
+query files(
+  $before: String
+  $after: String
+  $first: Int
+  $last: Int
+  $filters: FileFilters
+) {
+  files(
+    before: $before
+    after: $after
+    first: $first
+    last: $last
+    filters: $filters
+  ) {
+    totalCount
+    edges {
+      cursor
+      node {
+        ...FileFragment
+      }
+    }
+  }
+}
+"""
+)

primitive/utils/auth.py

@@ -1,26 +1,34 @@
-from ..graphql.sdk import create_session
 import sys
 
+from loguru import logger
+
+from ..graphql.sdk import create_session
+
+
+def create_new_session(primitive):
+    token = primitive.host_config.get("token")
+    transport = primitive.host_config.get("transport")
+    fingerprint = primitive.host_config.get("fingerprint")
+
+    if not token or not transport:
+        logger.enable("primitive")
+        logger.error(
+            "CLI is not configured. Run `primitive config` to add an auth token."
+        )
+        sys.exit(1)
+
+    return create_session(
+        host=primitive.host,
+        token=token,
+        transport=transport,
+        fingerprint=fingerprint,
+    )
+
 
 def guard(func):
     def wrapper(self, *args, **kwargs):
         if self.primitive.session is None:
-            token = self.primitive.host_config.get("token")
-            transport = self.primitive.host_config.get("transport")
-            fingerprint = self.primitive.host_config.get("fingerprint")
-
-            if not token or not transport:
-                print(
-                    "CLI is not configured. Run primitive config to add an auth token."
-                )
-                sys.exit(1)
-
-            self.primitive.session = create_session(
-                host=self.primitive.host,
-                token=token,
-                transport=transport,
-                fingerprint=fingerprint,
-            )
+            self.primitive.session = create_new_session(self.primitive)
 
         return func(self, *args, **kwargs)
 

primitive/utils/chunk_size.py

@@ -0,0 +1,87 @@
+import math
+
+import speedtest
+
+from .memory_size import MemorySize
+
+max_threads = 4
+
+
+def get_upload_speed_mb() -> int:
+    """
+    Calculate the Bytes per Second upload speed using the speedtest-cli library.
+    Return the upload speed in a round "MB" MegaBytes to the power of two format.
+    """
+    speedtest_client = speedtest.Speedtest(secure=True)
+    speedtest_client.get_best_server()
+    upload_speed_bytes = speedtest_client.upload()
+
+    upload_speed_mb = MemorySize(upload_speed_bytes, "B")
+    upload_speed_mb.convert_to("MB")
+    return int(upload_speed_mb.value)
+
+
+def nearest_classic_power_of_two_mb(chunk_size_bytes):
+    """
+    Finds the nearest 'classic' power-of-2 multiple in MB (e.g., 8, 16, 32 MB).
+
+    Args:
+        chunk_size_bytes (int): The chunk size in bytes.
+
+    Returns:
+        int: The closest size in bytes that corresponds to 8, 16, 32, etc. MB.
+    """
+    # Convert bytes to MB
+    chunk_size_mb = chunk_size_bytes / (10**6)
+
+    # Calculate log2 of the chunk size in MB
+    log2_size = math.log2(chunk_size_mb)
+
+    # Find the nearest powers of 2
+    lower_mb = 2 ** math.floor(log2_size)
+    upper_mb = 2 ** math.ceil(log2_size)
+
+    # Convert back to bytes
+    lower_bytes = lower_mb * (10**6)
+    upper_bytes = upper_mb * (10**6)
+
+    # Determine the closest one in bytes
+    return (
+        lower_bytes
+        if abs(chunk_size_bytes - lower_bytes) <= abs(chunk_size_bytes - upper_bytes)
+        else upper_bytes
+    )
+
+
+def calculate_optimal_chunk_size(
+    upload_speed_mb: int,
+    file_size_bytes: int,
+    num_workers: int = 4,
+    optimal_time_seconds: int = 5,
+):
+    """
+    Calculate the optimal chunk size for a multipart upload based on network speed, cores, and file size.
+
+    :param upload_speed_mbps: The upload speed in Mbit/s (but a single integer represented as MB).
+    :param file_size_bytes: The size of the file in bytes.
+    :param num_workers: The number of threads available for multi-threading (default is 4).
+    :param optimal_time_seconds: The target upload time per chunk in seconds (default is 5).
+
+    :return: A tuple (optimal_chunk_size_bytes, chunk_count, list_of_urls)
+    """
+
+    # Estimate transfer rate per thread (Bytes/sec)
+    thread_speed_mbps = int(upload_speed_mb) / num_workers  # Mbit/s per thread
+    thread_speed_bps = thread_speed_mbps * 125_000  # Convert to Bytes/sec
+
+    # Calculate optimal chunk size (Bytes)
+    optimal_chunk_size_bytes = thread_speed_bps * optimal_time_seconds
+    rounded_chunk_size_bytes = nearest_classic_power_of_two_mb(optimal_chunk_size_bytes)
+
+    # Adjust chunk size to ensure it's an integer and divide the file size into chunks
+    chunk_count = math.ceil(file_size_bytes / rounded_chunk_size_bytes)
+    # final_chunk_size_bytes = math.ceil(
+    #     int(file_size_bytes) / chunk_count
+    # )  # Round up to fit file size evenly
+
+    return rounded_chunk_size_bytes, chunk_count

primitive/utils/files.py

@@ -7,16 +7,19 @@ import os
 def find_files_for_extension(source: Path, extensions: Tuple[str]) -> List[Path]:
     matching_files = []
     logger.debug(f"Looking for files at {source} with extensions {extensions}")
-    # for those on python 3.12+
-    # for dirpath, dirnames, filenames in source.walk():
-    #     for filename in filenames:
-    #         if filename.endswith(extensions):
-    #             matching_files.append(dirpath.joinpath(filename))
 
-    for dirpath, dirnames, filenames in os.walk(source):
+    has_walk = getattr(source, "walk", None)
+
+    if has_walk:
+        files = source.walk()
+    else:
+        files = os.walk(source)
+
+    for dirpath, dirnames, filenames in files:
         for filename in filenames:
             if filename.endswith(extensions):
-                matching_files.append(Path(dirpath).joinpath(filename))
+                matching_files.append(dirpath.joinpath(filename))
+    
     logger.debug(
         f"Found {len(matching_files)} following files that match: {matching_files}"
     )

{primitive-0.1.68.dist-info → primitive-0.1.69.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.68
+Version: 0.1.69
 Project-URL: Documentation, https://github.com//primitivecorp/primitive-cli#readme
 Project-URL: Issues, https://github.com//primitivecorp/primitive-cli/issues
 Project-URL: Source, https://github.com//primitivecorp/primitive-cli
@@ -23,6 +23,7 @@ Requires-Dist: loguru
 Requires-Dist: paramiko[invoke]
 Requires-Dist: primitive-pal==0.1.4
 Requires-Dist: pyyaml
+Requires-Dist: speedtest-cli
 Description-Content-Type: text/markdown
 
 # primitive

{primitive-0.1.68.dist-info → primitive-0.1.69.dist-info}/RECORD

@@ -1,14 +1,14 @@
-primitive/__about__.py,sha256=HwbDpGY94x-5mM9iqNDH53F3G8OAv0XgJ3P44BhArVQ,130
+primitive/__about__.py,sha256=saM2C0K9xd6ArRZ-ka1Araq4qbPyGBjdh5fngoELO7c,130
 primitive/__init__.py,sha256=bwKdgggKNVssJFVPfKSxqFMz4IxSr54WWbmiZqTMPNI,106
-primitive/cli.py,sha256=CGmWiqqCLMHtHGOUPuf3tVO6VvChBZ1VdSwCCglnBgA,2582
-primitive/client.py,sha256=P7cCDperMu3pxlmRAP-H2owM-cj1kRlZWrqujxnWa4o,2473
+primitive/cli.py,sha256=CiI60bG3UZyNFuLTpchr0KeJRG5SALj455Ob11CegGE,2412
+primitive/client.py,sha256=PPyIQRvKKSqCF9RRF5mJJ4Vqqolpzy1YXqffNLKIvAA,2390
 primitive/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/agent/actions.py,sha256=Hosy2o2FntfBtcNqqHuMFq9dm99EVfySy0v2JGeufvc,6474
 primitive/agent/commands.py,sha256=-dVDilELfkGfbZB7qfEPs77Dm1oT62qJj4tsIk4KoxI,254
-primitive/agent/process.py,sha256=LVI-RB4a0YEuXUTYMXKL5Xi9euNwUI2nxj00mv8EFOg,2253
+primitive/agent/process.py,sha256=7o8axjJ1OauKaFBL0jbZL9tGlZdZbDCXAdT5F-S_XQ8,2541
 primitive/agent/provision.py,sha256=rmwnro1K5F8mwtd45XAq7RVQmpDWnbBCQ8X_qgWhm3M,1546
-primitive/agent/runner.py,sha256=URCyk9Di423tTWAT6ObQcT62F-n27Q2MFGTcTNCPU8Y,7754
-primitive/agent/uploader.py,sha256=W-aXUgKZvcm9LbTXq8su_cgBl_mFrmcFfkkU9t8W04Q,3002
+primitive/agent/runner.py,sha256=VGHvlu0JOu8sKcia7HFzFtynH596lKGH-mQY94lqpq0,8301
+primitive/agent/uploader.py,sha256=CRy928vI4z22PcJ-i8BOwAZnvut-jit64XM741xbDxM,2947
 primitive/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/auth/actions.py,sha256=MPsG9LcKcOPwA7gZ9Ewk0PZJhTQvIrGfODdz4GxSzgA,999
 primitive/auth/commands.py,sha256=JahUq0E2e7Xa-FX1WEUv7TgM6ieDvNH4VwRRtxAW7HE,2340
@@ -24,10 +24,12 @@ primitive/exec/actions.py,sha256=onBOsMwANCKjCf8aSmDhep9RTX7LhtS8nlcjZM6av1w,263
 primitive/exec/commands.py,sha256=66LO2kkJC-ynNZQpUCXv4Ol15QoacdSZAHblePDcmLo,510
 primitive/exec/interactive.py,sha256=TscY6s2ZysijidKPheq6y-fCErUVLS0zcdTW8XyFWGI,2435
 primitive/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/files/actions.py,sha256=zA1vGXz56oKM1_eiDHGO0GVPHt0QMNrhWDHxQktiEqw,6744
-primitive/files/commands.py,sha256=x1fxixMrZFvYZGeQb3u5ElsbmWXMmYGq0f_zZArGp8Q,1084
+primitive/files/actions.py,sha256=ZBajWkrvM_pZjJrwXK-_LGnDP6qrUu4LxWg7ZF3RGHg,12444
+primitive/files/commands.py,sha256=ZNW4y8JZF1li7P5ej1r-Xcqu0iGpRRlMYvthuZOLLbQ,1163
 primitive/files/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/files/graphql/mutations.py,sha256=SWxq6rwVWhouiuC72--Avpg9vybURFxmxiwkMY6dX7E,642
+primitive/files/graphql/fragments.py,sha256=II6WHZjzSqX4IELwdiWokqHTKvDq6mMHF5gp3rLnj3U,231
+primitive/files/graphql/mutations.py,sha256=Da_e6WSp-fsCYVE9A6SGkIQy9WDzjeQycNyHEn7vJqE,935
+primitive/files/graphql/queries.py,sha256=_ky-IRz928sKeSJuqaggTPxV4CGgmho3OyaAFu1z7nw,397
 primitive/git/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/git/actions.py,sha256=0KHeHViZZqIhF6-Eqvhs0g_UmglqyWrOQKElQCm6jVw,1506
 primitive/git/commands.py,sha256=sCeSjkRgSEjCEsB5seXgB_h6xfk0KpvMvzMKoRfUbRA,1177
@@ -51,9 +53,6 @@ primitive/jobs/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 primitive/jobs/graphql/fragments.py,sha256=xtT168P-ChEj3UhSXxFiYPgYuMDyey9bXYkk-TtM3a4,542
 primitive/jobs/graphql/mutations.py,sha256=8ASvCmwQh7cMeeiykOdYaYVryG8FRIuVF6v_J8JJZuw,219
 primitive/jobs/graphql/queries.py,sha256=BrU_GnLjK0bTAmWsLSmGEUea7EM8MqTKxN1Qp6sSjwc,1597
-primitive/lint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/lint/actions.py,sha256=tWsrht1dowGprcZjEUtjCJzozEQmh9sv2_C2__YHIOI,2825
-primitive/lint/commands.py,sha256=3CZvkOEMpJspJWmaQzA5bpPKx0_VCijQIXA9l-eTnZE,487
 primitive/organizations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/organizations/actions.py,sha256=o7WnTONtH-WI0kzn71Uq-kF0CRjDS8Xb9YA7DIjYnwY,1085
 primitive/organizations/commands.py,sha256=_dwgVEJCqMa5VgB_7P1wLPFc0AuT1p9dtyR9JRr4kpw,487
@@ -79,22 +78,20 @@ primitive/reservations/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 primitive/reservations/graphql/fragments.py,sha256=_TQfJeHky-Hh3WCHWobQ6-A1lpSvU-YkS0V9cqj2nOU,476
 primitive/reservations/graphql/mutations.py,sha256=IqzwQL7OclN7RpIcidrTQo9cGYofY7wqoBOdnY0pwN8,651
 primitive/reservations/graphql/queries.py,sha256=x31wTRelskX2fc0fx2qrY7XT1q74nvzLv_Xef3o9weg,746
-primitive/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/sim/actions.py,sha256=oR77UmCp6PxDEuKvoNejeHOG6E5r6uHax3G9OZYoofM,4810
-primitive/sim/commands.py,sha256=8PaOfL1MO6qxTn7mNVRnBU1X2wa3gk_mlbAhBW6MnI0,591
 primitive/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/utils/actions.py,sha256=HOFrmM3-0A_A3NS84MqrZ6JmQEiiPSoDqEeuu6b_qfQ,196
-primitive/utils/auth.py,sha256=TtJKTR6tLmNrtWbOjJI-KJh4ZSJ1uG7ApE9GcY63m00,836
+primitive/utils/auth.py,sha256=kKvLjBCQXTo3k92RKhQj90B5clOIMBp6ocgaBqkGQBg,867
 primitive/utils/cache.py,sha256=FHGmVWYLJFQOazpXXcEwI0YJEZbdkgG39nOLdOv6VNk,1575
+primitive/utils/chunk_size.py,sha256=PAuVuirUTA9oRXyjo1c6MWxo31WVBRkWMuWw-AS58Bw,2914
 primitive/utils/config.py,sha256=DlFM5Nglo22WPtbpZSVtH7NX-PTMaKYlcrUE7GPRG4c,1058
-primitive/utils/files.py,sha256=Yv__bQes3YIlzhOT9kVxtYhoA5CmUjPSvphl9PZ41k4,867
+primitive/utils/files.py,sha256=Aleb1U2pZZBGR24QYGP7LWt8A6WMaHM75_9oG9s2kbg,750
 primitive/utils/git.py,sha256=1qNOu8X-33CavmrD580BmrFhD_WVO9PGWHUUboXJR_g,663
 primitive/utils/memory_size.py,sha256=4xfha21kW82nFvOTtDFx9Jk2ZQoEhkfXii-PGNTpIUk,3058
 primitive/utils/printer.py,sha256=f1XUpqi5dkTL3GWvYRUGlSwtj2IxU1q745T4Fxo7Tn4,370
 primitive/utils/shell.py,sha256=j7E1YwgNWw57dFHVfEbqRNVcPHX0xDefX2vFSNgeI_8,1648
 primitive/utils/verible.py,sha256=Zb5NUISvcaIgEvgCDBWr-GCoceMa79Tcwvr5Wl9lfnA,2252
-primitive-0.1.68.dist-info/METADATA,sha256=2zoWXWeqIRffEJBD8D_kzJ5zbGTJIh5H6TVe6wSEWlU,3777
-primitive-0.1.68.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-primitive-0.1.68.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
-primitive-0.1.68.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
-primitive-0.1.68.dist-info/RECORD,,
+primitive-0.1.69.dist-info/METADATA,sha256=8j9Ig3fsWbfeyVOD3XJAprWrNRt-25-iWOBQ0ecAmgo,3806
+primitive-0.1.69.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+primitive-0.1.69.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
+primitive-0.1.69.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
+primitive-0.1.69.dist-info/RECORD,,