lamin_cli 1.12.0__py2.py3-none-any.whl → 1.12.1__py2.py3-none-any.whl

lamin_cli/compute/modal.py

@@ -1,174 +1,174 @@
-import os
-import subprocess
-import sys
-import threading
-from pathlib import Path
-
-import lamindb_setup as ln_setup
-import modal
-
-
-def run_script(path: Path) -> dict:
-    """Takes a path to a script for running it as a function through Modal."""
-    result = {"success": False, "output": "", "error": ""}
-
-    def stream_output(stream, capture_list):
-        """Read from stream line by line and print in real-time while also capturing to a list."""
-        for line in iter(stream.readline, ""):
-            print(line, end="")  # Print in real-time
-            capture_list.append(line)
-        stream.close()
-
-    if not path.exists():
-        raise FileNotFoundError(f"Script file not found: {path}")
-
-    try:
-        # Run the script using subprocess
-        process = subprocess.Popen(
-            [sys.executable, path.as_posix()],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-            bufsize=1,  # Line buffered
-        )
-
-        # Capture output and error while streaming stdout in real-time
-        stdout_lines: list[str] = []
-        stderr_lines: list[str] = []
-
-        # Create threads to handle stdout and stderr streams
-        stdout_thread = threading.Thread(
-            target=stream_output, args=(process.stdout, stdout_lines)
-        )
-        stderr_thread = threading.Thread(
-            target=stream_output, args=(process.stderr, stderr_lines)
-        )
-
-        # Set as daemon threads so they exit when the main program exits
-        stdout_thread.daemon = True
-        stderr_thread.daemon = True
-
-        # Start the threads
-        stdout_thread.start()
-        stderr_thread.start()
-
-        # Wait for the process to complete
-        return_code = process.wait()
-
-        # Wait for the threads to finish
-        stdout_thread.join()
-        stderr_thread.join()
-
-        # Join the captured output
-        stdout_output = "".join(stdout_lines)
-        stderr_output = "".join(stderr_lines)
-
-        # Check return code
-        if return_code == 0:
-            result["success"] = True
-            result["output"] = stdout_output
-        else:
-            result["error"] = stderr_output
-
-    except Exception as e:
-        import traceback
-
-        result["error"] = str(e) + "\n" + traceback.format_exc()
-    return result
-
-
-class Runner:
-    def __init__(
-        self,
-        app_name: str,
-        local_mount_dir: str | Path = "./scripts",
-        remote_mount_dir: str | Path = "/scripts",
-        image_url: str | None = None,
-        packages: list[str] | None = None,
-        cpu: float | None = None,
-        gpu: str | None = None,
-    ):
-        self.app_name = app_name  # we use the LaminDB project name as the app name
-        self.app = self.create_modal_app(app_name)
-
-        self.local_mount_dir = local_mount_dir
-        self.remote_mount_dir = remote_mount_dir
-
-        self.image = self.create_modal_image(
-            local_dir=local_mount_dir, packages=packages, image_url=image_url
-        )
-
-        local_secrets = self._configure_local_secrets()
-
-        self.modal_function = self.app.function(
-            image=self.image, cpu=cpu, gpu=gpu, secrets=[local_secrets]
-        )(run_script)
-
-    def run(self, script_local_path: Path) -> None:
-        script_remote_path = self.local_to_remote_path(str(script_local_path))
-        with modal.enable_output(show_progress=True):  # Prints out modal logs
-            with self.app.run():
-                self.modal_function.remote(Path(script_remote_path))
-
-    def create_modal_app(self, app_name: str) -> modal.App:
-        app = modal.App(app_name)
-        return app
-
-    def local_to_remote_path(self, local_path: str | Path) -> str:
-        local_path = Path(local_path).absolute()
-        local_mount_dir = Path(self.local_mount_dir).absolute()
-        remote_mount_dir = Path(self.remote_mount_dir)
-
-        # Check if local_path is inside local_mount_dir
-        try:
-            # This will raise ValueError if local_path is not relative to local_mount_dir
-            relative_path = local_path.relative_to(local_mount_dir)
-        except ValueError as err:
-            raise ValueError(
-                f"Local path '{local_path}' is not inside the mount directory '{local_mount_dir}'"
-            ) from err
-
-        # Join remote_mount_dir with the relative path
-        remote_path = remote_mount_dir / relative_path
-
-        # Return as string with normalized separators
-        return remote_path.as_posix()
-
-    def _configure_local_secrets(self) -> dict:
-        if ln_setup.settings.user.api_key is None:
-            raise ValueError("Please authenticate via: lamin login")
-
-        all_env_variables = {
-            "LAMIN_API_KEY": ln_setup.settings.user.api_key,
-            "LAMIN_CURRENT_PROJECT": self.app_name,
-            "LAMIN_CURRENT_INSTANCE": ln_setup.settings.instance.slug,
-        }
-        local_secrets = modal.Secret.from_dict(all_env_variables)
-        return local_secrets
-
-    def create_modal_image(
-        self,
-        python_version: str = "3.12",
-        packages: list[str] | None = None,
-        local_dir: str | Path = "./scripts",
-        remote_dir: str = "/scripts/",
-        image_url: str | None = None,
-        env_variables: dict | None = None,
-    ) -> modal.Image:
-        if env_variables is None:
-            env_variables = {}
-        base_packages = ["lamindb", "httpx_retries"]
-        if packages is None:
-            packages = base_packages
-        else:
-            packages += base_packages
-        if image_url is None:
-            image = modal.Image.debian_slim(python_version=python_version)
-        else:
-            image = modal.Image.from_registry(image_url, add_python=python_version)
-        return (
-            image.pip_install(packages)
-            .env(env_variables)
-            .add_local_python_source("lamindb", "lamindb_setup", copy=True)
-            .add_local_dir(local_dir, remote_dir)
-        )
+import os
+import subprocess
+import sys
+import threading
+from pathlib import Path
+
+import lamindb_setup as ln_setup
+import modal
+
+
+def run_script(path: Path) -> dict:
+    """Takes a path to a script for running it as a function through Modal."""
+    result = {"success": False, "output": "", "error": ""}
+
+    def stream_output(stream, capture_list):
+        """Read from stream line by line and print in real-time while also capturing to a list."""
+        for line in iter(stream.readline, ""):
+            print(line, end="")  # Print in real-time
+            capture_list.append(line)
+        stream.close()
+
+    if not path.exists():
+        raise FileNotFoundError(f"Script file not found: {path}")
+
+    try:
+        # Run the script using subprocess
+        process = subprocess.Popen(
+            [sys.executable, path.as_posix()],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1,  # Line buffered
+        )
+
+        # Capture output and error while streaming stdout in real-time
+        stdout_lines: list[str] = []
+        stderr_lines: list[str] = []
+
+        # Create threads to handle stdout and stderr streams
+        stdout_thread = threading.Thread(
+            target=stream_output, args=(process.stdout, stdout_lines)
+        )
+        stderr_thread = threading.Thread(
+            target=stream_output, args=(process.stderr, stderr_lines)
+        )
+
+        # Set as daemon threads so they exit when the main program exits
+        stdout_thread.daemon = True
+        stderr_thread.daemon = True
+
+        # Start the threads
+        stdout_thread.start()
+        stderr_thread.start()
+
+        # Wait for the process to complete
+        return_code = process.wait()
+
+        # Wait for the threads to finish
+        stdout_thread.join()
+        stderr_thread.join()
+
+        # Join the captured output
+        stdout_output = "".join(stdout_lines)
+        stderr_output = "".join(stderr_lines)
+
+        # Check return code
+        if return_code == 0:
+            result["success"] = True
+            result["output"] = stdout_output
+        else:
+            result["error"] = stderr_output
+
+    except Exception as e:
+        import traceback
+
+        result["error"] = str(e) + "\n" + traceback.format_exc()
+    return result
+
+
+class Runner:
+    def __init__(
+        self,
+        app_name: str,
+        local_mount_dir: str | Path = "./scripts",
+        remote_mount_dir: str | Path = "/scripts",
+        image_url: str | None = None,
+        packages: list[str] | None = None,
+        cpu: float | None = None,
+        gpu: str | None = None,
+    ):
+        self.app_name = app_name  # we use the LaminDB project name as the app name
+        self.app = self.create_modal_app(app_name)
+
+        self.local_mount_dir = local_mount_dir
+        self.remote_mount_dir = remote_mount_dir
+
+        self.image = self.create_modal_image(
+            local_dir=local_mount_dir, packages=packages, image_url=image_url
+        )
+
+        local_secrets = self._configure_local_secrets()
+
+        self.modal_function = self.app.function(
+            image=self.image, cpu=cpu, gpu=gpu, secrets=[local_secrets]
+        )(run_script)
+
+    def run(self, script_local_path: Path) -> None:
+        script_remote_path = self.local_to_remote_path(str(script_local_path))
+        with modal.enable_output(show_progress=True):  # Prints out modal logs
+            with self.app.run():
+                self.modal_function.remote(Path(script_remote_path))
+
+    def create_modal_app(self, app_name: str) -> modal.App:
+        app = modal.App(app_name)
+        return app
+
+    def local_to_remote_path(self, local_path: str | Path) -> str:
+        local_path = Path(local_path).absolute()
+        local_mount_dir = Path(self.local_mount_dir).absolute()
+        remote_mount_dir = Path(self.remote_mount_dir)
+
+        # Check if local_path is inside local_mount_dir
+        try:
+            # This will raise ValueError if local_path is not relative to local_mount_dir
+            relative_path = local_path.relative_to(local_mount_dir)
+        except ValueError as err:
+            raise ValueError(
+                f"Local path '{local_path}' is not inside the mount directory '{local_mount_dir}'"
+            ) from err
+
+        # Join remote_mount_dir with the relative path
+        remote_path = remote_mount_dir / relative_path
+
+        # Return as string with normalized separators
+        return remote_path.as_posix()
+
+    def _configure_local_secrets(self) -> dict:
+        if ln_setup.settings.user.api_key is None:
+            raise ValueError("Please authenticate via: lamin login")
+
+        all_env_variables = {
+            "LAMIN_API_KEY": ln_setup.settings.user.api_key,
+            "LAMIN_CURRENT_PROJECT": self.app_name,
+            "LAMIN_CURRENT_INSTANCE": ln_setup.settings.instance.slug,
+        }
+        local_secrets = modal.Secret.from_dict(all_env_variables)
+        return local_secrets
+
+    def create_modal_image(
+        self,
+        python_version: str = "3.12",
+        packages: list[str] | None = None,
+        local_dir: str | Path = "./scripts",
+        remote_dir: str = "/scripts/",
+        image_url: str | None = None,
+        env_variables: dict | None = None,
+    ) -> modal.Image:
+        if env_variables is None:
+            env_variables = {}
+        base_packages = ["lamindb", "httpx_retries"]
+        if packages is None:
+            packages = base_packages
+        else:
+            packages += base_packages
+        if image_url is None:
+            image = modal.Image.debian_slim(python_version=python_version)
+        else:
+            image = modal.Image.from_registry(image_url, add_python=python_version)
+        return (
+            image.pip_install(packages)
+            .env(env_variables)
+            .add_local_python_source("lamindb", "lamindb_setup", copy=True)
+            .add_local_dir(local_dir, remote_dir)
+        )

lamin_cli/urls.py

@@ -1,10 +1,10 @@
-def decompose_url(url: str) -> tuple[str, str, str]:
-    assert any(
-        keyword in url for keyword in ["transform", "artifact", "collection", "record"]
-    )
-    for entity in ["transform", "artifact", "collection", "record"]:
-        if entity in url:
-            break
-    uid = url.split(f"{entity}/")[1]
-    instance_slug = "/".join(url.split("/")[3:5])
-    return instance_slug, entity, uid
+def decompose_url(url: str) -> tuple[str, str, str]:
+    assert any(
+        keyword in url for keyword in ["transform", "artifact", "collection", "record"]
+    )
+    for entity in ["transform", "artifact", "collection", "record"]:
+        if entity in url:
+            break
+    uid = url.split(f"{entity}/")[1]
+    instance_slug = "/".join(url.split("/")[3:5])
+    return instance_slug, entity, uid

{lamin_cli-1.12.0.dist-info → lamin_cli-1.12.1.dist-info}/METADATA

@@ -1,9 +1,10 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: lamin_cli
-Version: 1.12.0
+Version: 1.12.1
 Summary: Lamin CLI.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: rich-click>=1.7
 Project-URL: Home, https://github.com/laminlabs/lamin-cli
 

lamin_cli-1.12.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+lamin_cli/__init__.py,sha256=Y2VF3ydcKBUCWFHYlmXXl0KXH8Xo6OuvgzIKp8dAtx0,632
+lamin_cli/__main__.py,sha256=09tbCQQx-6DgDpV84BfRQ0_PW_WAb3hLBcQBE7t62wI,28753
+lamin_cli/_annotate.py,sha256=LCjZuxz1HuUhWjlSVl5vxOcmtctaYwpyVUOs8P2tL7I,1886
+lamin_cli/_cache.py,sha256=HuNRa4yb2KibBoE2FVqtFmUvb3b3UnX78EowWEt025s,1096
+lamin_cli/_context.py,sha256=hTcKialdtaaQC6b1RIQP0_uw927ycRlXepOrTB9H_Ws,2468
+lamin_cli/_delete.py,sha256=_HewMItVM95_03TPkl-fkfcOW60CvUUlR3bF_cKYTRA,3146
+lamin_cli/_io.py,sha256=5YF9-D999m6QB79J5pWA7agxZ52i30y2AzyWF_qsHBs,5322
+lamin_cli/_load.py,sha256=8BPRdG2VBiGdmiOVvxCE3u4vHe5ORMCbfKcnVjCr9-I,8648
+lamin_cli/_migration.py,sha256=GFOpiqh0esy7frR-sLymyY49KnQ-ATFCu1QXf1GXo7U,1289
+lamin_cli/_save.py,sha256=SnM-SoeErYKg20sqfeWufXsqdam3MM9J6haAmqxFJqo,14156
+lamin_cli/_settings.py,sha256=1GvwUscOWgT69uMGfo8z9IRlOYMdRessvl9E80pZB7E,4935
+lamin_cli/urls.py,sha256=s1qi1X-IEbyIqBlYOuBtMMEdKdz-g9RBmXZO9WY6c0o,411
+lamin_cli/clone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lamin_cli/clone/_clone_verification.py,sha256=vaEj4FdCNCumZrC7gnoCImOa1nwWSf3cZ30B1zyowAg,1891
+lamin_cli/clone/create_sqlite_clone_and_import_db.py,sha256=8ydAJTyZkDm5t6pRKDEb4K4S8zVzJYuwX61KGGlufGM,1629
+lamin_cli/compute/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lamin_cli/compute/modal.py,sha256=HIsfBbKV4RMiZcoi8Uk2YOS-0O-QBygSWNLMYHwAwS0,6129
+lamin_cli-1.12.1.dist-info/entry_points.txt,sha256=Qms85i9cZPlu-U7RnVZhFsF7vJ9gaLZUFkCjcGcXTpg,49
+lamin_cli-1.12.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lamin_cli-1.12.1.dist-info/WHEEL,sha256=Dyt6SBfaasWElUrURkknVFAZDHSTwxg3PaTza7RSbkY,100
+lamin_cli-1.12.1.dist-info/METADATA,sha256=A0lBle_Wj9JGHNlG7NxijJ1tFHUZiycPGqgF6XfLMGk,360
+lamin_cli-1.12.1.dist-info/RECORD,,

{lamin_cli-1.12.0.dist-info → lamin_cli-1.12.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: flit 3.10.1
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any