latch 2.45.2.dev2__tar.gz → 2.45.3__tar.gz

latch-2.45.3/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: latch
+Version: 2.45.3
+Summary: The Latch SDK
+Author-email: kenny@latch.bio
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8,<3.12
+Provides-Extra: snakemake
+Provides-Extra: pandas
+License-File: LICENSE

{latch-2.45.2.dev2 → latch-2.45.3}/latch/ldata/type.py

@@ -1,14 +1,8 @@
 from enum import Enum
-from typing import Optional
 
 
 class LatchPathError(RuntimeError):
-    def __init__(
-        self,
-        message: str,
-        remote_path: Optional[str] = None,
-        acc_id: Optional[str] = None,
-    ):
+    def __init__(self, message: str, remote_path: str = None, acc_id: str = None):
         super().__init__(message)
         self.message = message
         self.remote_path = remote_path

{latch-2.45.2.dev2 → latch-2.45.3}/latch/resources/tasks.py

@@ -34,12 +34,9 @@ from flytekit import task
 from flytekitplugins.pod import Pod
 from kubernetes.client.models import (
     V1Container,
-    V1PersistentVolumeClaimVolumeSource,
     V1PodSpec,
     V1ResourceRequirements,
     V1Toleration,
-    V1Volume,
-    V1VolumeMount,
 )
 
 from latch_cli.constants import Units
@@ -477,43 +474,3 @@ def custom_task(
     return functools.partial(
         task, task_config=_custom_task_config(cpu, memory, storage_gib), timeout=timeout
     )
-
-
-def nextflow_runtime_task(cpu: int, memory: int):
-    primary_container = V1Container(name="primary")
-    resources = V1ResourceRequirements(
-        requests={
-            "cpu": str(cpu),
-            "memory": f"{memory}Gi",
-            "ephemeral-storage": "20Gi",
-        },
-        limits={"cpu": str(cpu), "memory": f"{memory}Gi", "ephemeral-storage": "20Gi"},
-    )
-    primary_container.resources = resources
-    volume_mounts = [V1VolumeMount(mount_path="/nf-workdir", name="nextflow-workdir")]
-    primary_container.volume_mounts = volume_mounts
-
-    task_config = Pod(
-        annotations={
-            "io.kubernetes.cri-o.userns-mode": (
-                "private:uidmapping=0:1048576:65536;gidmapping=0:1048576:65536"
-            )
-        },
-        pod_spec=V1PodSpec(
-            runtime_class_name="sysbox-runc",
-            automount_service_account_token=True,
-            containers=[primary_container],
-            volumes=[
-                V1Volume(
-                    name="nextflow-workdir",
-                    persistent_volume_claim=V1PersistentVolumeClaimVolumeSource(
-                        # this value will be injected by flytepropeller
-                        claim_name="nextflow-pvc-placeholder"
-                    ),
-                )
-            ],
-        ),
-        primary_container_name="primary",
-    )
-
-    return functools.partial(task, task_config=task_config)

{latch-2.45.2.dev2 → latch-2.45.3}/latch/types/directory.py

@@ -114,10 +114,8 @@ class LatchDir(FlyteDirectory):
         self._path_generated = False
 
         if is_valid_url(self.path) and remote_path is None:
-            self._raw_remote_path = str(path)
             self._remote_directory = self.path
         else:
-            self._raw_remote_path = str(remote_path)
             self._remote_directory = None if remote_path is None else str(remote_path)
 
         if kwargs.get("downloader") is not None:

{latch-2.45.2.dev2 → latch-2.45.3}/latch/types/file.py

@@ -77,10 +77,8 @@ class LatchFile(FlyteFile):
         self._path_generated = False
 
         if is_valid_url(self.path) and remote_path is None:
-            self._raw_remote_path = str(path)
             self._remote_path = str(path)
         else:
-            self._raw_remote_path = str(remote_path)
             self._remote_path = None if remote_path is None else str(remote_path)
 
         if kwargs.get("downloader") is not None:

{latch-2.45.2.dev2 → latch-2.45.3}/latch/types/metadata.py

@@ -1,32 +1,13 @@
-import csv
-import functools
 import re
-from dataclasses import Field, asdict, dataclass, field, fields, is_dataclass
+from dataclasses import Field, asdict, dataclass, field
 from enum import Enum
 from pathlib import Path
-from textwrap import dedent, indent
-from typing import (
-    Any,
-    Callable,
-    ClassVar,
-    Collection,
-    Dict,
-    Generic,
-    List,
-    Literal,
-    Optional,
-    Protocol,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    get_args,
-    get_origin,
-)
+from textwrap import indent
+from typing import Any, ClassVar, Dict, List, Optional, Protocol, Tuple, Type, Union
 
 import click
 import yaml
-from typing_extensions import Annotated, TypeAlias
+from typing_extensions import TypeAlias
 
 from latch_cli.snakemake.config.utils import validate_snakemake_type
 from latch_cli.utils import identifier_suffix_from_str
@@ -35,6 +16,7 @@ from .directory import LatchDir
 from .file import LatchFile
 
 
+@dataclass
 class LatchRule:
     """Class describing a rule that a parameter input must follow"""
 
@@ -406,33 +388,31 @@ class _IsDataclass(Protocol):
 
 
 ParameterType: TypeAlias = Union[
-    None,
-    int,
-    float,
-    str,
-    bool,
-    LatchFile,
-    LatchDir,
-    Enum,
-    _IsDataclass,
-    Collection["ParameterType"],
+    Type[None],
+    Type[int],
+    Type[float],
+    Type[str],
+    Type[bool],
+    Type[Enum],
+    Type[_IsDataclass],
+    Type[List["ParameterType"]],
+    Type[LatchFile],
+    Type[LatchDir],
 ]
 
 
-T = TypeVar("T", bound=ParameterType)
-
-
 @dataclass
-class SnakemakeParameter(Generic[T], LatchParameter):
-    type: Optional[Type[T]] = None
+class SnakemakeParameter(LatchParameter):
+    type: Optional[ParameterType] = None
     """
     The python type of the parameter.
     """
-    default: Optional[T] = None
+    # todo(ayush): needs to be typed properly
+    default: Optional[Any] = None
 
 
 @dataclass
-class SnakemakeFileParameter(SnakemakeParameter[Union[LatchFile, LatchDir]]):
+class SnakemakeFileParameter(SnakemakeParameter):
     """
     Deprecated: use `file_metadata` keyword in `SnakemakeMetadata` instead
     """
@@ -476,108 +456,6 @@ class SnakemakeFileMetadata:
     """
 
 
-@dataclass
-class NextflowParameter(Generic[T], LatchParameter):
-    type: Optional[Type[T]] = None
-    """
-    The python type of the parameter.
-    """
-    default: Optional[T] = None
-    """
-    Default value of the parameter
-    """
-
-    samplesheet_type: Literal["csv", "tsv", None] = None
-    """
-    The type of samplesheet to construct from the input parameter.
-
-    Only used if the provided parameter is a samplesheet (samplesheet=True)
-    """
-    samplesheet_constructor: Optional[Callable[[T], Path]] = None
-    """
-    A custom samplesheet constructor.
-
-    Should return the path of the constructed samplesheet. If samplesheet_type is also specified, this takes precedence.
-    Only used if the provided parameter is a samplesheet (samplesheet=True)
-    """
-
-    def __post_init__(self):
-        if not self.samplesheet or self.samplesheet_constructor is not None:
-            return
-
-        t = self.type
-        if get_origin(t) is not list or not is_dataclass(get_args(t)[0]):
-            click.secho(
-                dedent("""\
-                Samplesheets must be a list of dataclasses.
-                """),
-                fg="red",
-            )
-            raise click.exceptions.Exit(1)
-
-        if self.samplesheet_type is not None:
-            delim = "," if self.samplesheet_type == "csv" else "\t"
-            self.samplesheet_constructor = functools.partial(
-                _samplesheet_constructor, t=get_args(self.type)[0], delim=delim
-            )
-            return
-
-        click.secho(
-            dedent("""\
-            A Samplesheet constructor is required for a samplesheet parameter. Please either provide a value for
-            `samplesheet_type` or provide a custom callable to the `samplesheet_constructor` argument.
-            """),
-            fg="red",
-        )
-        raise click.exceptions.Exit(1)
-
-
-DC = TypeVar("DC", bound=_IsDataclass)
-
-
-def _samplesheet_repr(v: Any) -> str:
-    if v is None:
-        return ""
-    if isinstance(v, LatchFile) or isinstance(v, LatchDir):
-        return v.remote_path
-    if isinstance(v, Enum):
-        return getattr(v, "value")
-
-    return str(v)
-
-
-def _samplesheet_constructor(samples: List[DC], t: DC, delim: str = ",") -> Path:
-    samplesheet = Path("samplesheet.csv")
-
-    with open(samplesheet, "w") as f:
-        writer = csv.DictWriter(f, [f.name for f in fields(t)], delimiter=delim)
-        writer.writeheader()
-
-        for sample in samples:
-            row_data = {
-                f.name: _samplesheet_repr(getattr(sample, f.name))
-                for f in fields(sample)
-            }
-            writer.writerow(row_data)
-
-    return samplesheet
-
-
-@dataclass(frozen=True)
-class NextflowRuntimeResources:
-    """Resources for Nextflow runtime tasks"""
-
-    cpus: Optional[int] = 4
-    """
-    Number of CPUs required for the task
-    """
-    memory: Optional[str] = 8
-    """
-    Memory required for the task (e.g. "1 GB")
-    """
-    storage_gib: Optional[int] = 100
-
-
 @dataclass
 class LatchMetadata:
     """Class for organizing workflow metadata
@@ -773,37 +651,3 @@ class SnakemakeMetadata(LatchMetadata):
 
 
 _snakemake_metadata: Optional[SnakemakeMetadata] = None
-
-
-@dataclass
-class NextflowMetadata(LatchMetadata):
-    name: Optional[str] = None
-    """
-    Name of the workflow
-    """
-    parameters: Dict[str, NextflowParameter] = field(default_factory=dict)
-    """
-    A dictionary mapping parameter names (strings) to `NextflowParameter` objects
-    """
-    runtime_resources: NextflowRuntimeResources = field(
-        default_factory=NextflowRuntimeResources
-    )
-    """
-    Resources (cpu/memory/storage) for Nextflow runtime task
-    """
-    output_dir: Optional[LatchDir] = None
-    """
-    Directory to dump Nextflow logs
-    """
-
-    def __post_init__(self):
-        if self.name is None:
-            self.name = f"nf_{identifier_suffix_from_str(self.display_name.lower())}"
-        else:
-            self.name = identifier_suffix_from_str(self.name)
-
-        global _nextflow_metadata
-        _nextflow_metadata = self
-
-
-_nextflow_metadata: Optional[NextflowMetadata] = None

latch-2.45.3/latch/utils.py

@@ -0,0 +1,179 @@
+import itertools
+import os
+from typing import Dict, TypedDict
+
+import gql
+import jwt
+from latch_sdk_config.user import user_config
+from latch_sdk_gql.execute import execute
+
+
+def account_id_from_token(token: str) -> str:
+    """Exchanges a valid JWT for a Latch account ID.
+
+    Latch account IDs are needed for any user-specific request, eg. register
+    workflows or copy files to Latch.
+
+    Args:
+        token: JWT
+
+    Returns:
+        A Latch account ID (UUID).
+    """
+    decoded_jwt = jwt.decode(token, options={"verify_signature": False})
+    try:
+        return decoded_jwt.get("id")
+    except KeyError as e:
+        raise ValueError("Your Latch access token is malformed") from e
+
+
+def retrieve_or_login() -> str:
+    """Returns a valid JWT to access Latch, prompting a login flow if needed.
+
+    Returns:
+        A JWT
+    """
+    from latch_cli.services.login import login
+
+    token = user_config.token
+    if token == "":
+        token = login()
+    return token
+
+
+class WSInfo(TypedDict):
+    workspace_id: str
+    name: str
+    default: bool
+
+
+def get_workspaces() -> Dict[str, WSInfo]:
+    """Retrieve workspaces that user can access.
+
+    Returns:
+        A dictionary mapping workspace IDs to workspace display names.
+    """
+    account_id = account_id_from_token(retrieve_or_login())
+    res = execute(
+        gql.gql(
+            """
+            query GetWorkspaces($accountId: BigInt!) {
+                userInfoByAccountId(accountId: $accountId) {
+                    id
+                    defaultAccount
+                }
+                teamInfoByAccountId(accountId: $accountId) {
+                    accountId
+                    displayName
+                }
+                teamInfos(filter: {owner: {accountId: {equalTo: $accountId}}}) {
+                    nodes {
+                        accountId
+                        displayName
+                    }
+                }
+                teamMembers(filter: {user: {accountId: {equalTo: $accountId}}}) {
+                    nodes {
+                        team {
+                            accountId
+                            displayName
+                        }
+                    }
+                }
+                orgInfos(filter: { ownerAccountId: { equalTo: $accountId } }) {
+                    nodes {
+                        teamInfosByOrgId(filter: { account: { removed: { equalTo: false } } }) {
+                            nodes {
+                                accountId
+                                displayName
+                            }
+                        }
+                    }
+                }
+                orgMembers(filter: { userAccountId: { equalTo: $accountId } }) {
+                    nodes {
+                        org {
+                            teamInfosByOrgId(filter: { account: { removed: { equalTo: false } } }) {
+                                nodes {
+                                    accountId
+                                    displayName
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        """
+        ),
+        {"accountId": account_id},
+    )
+
+    owned_teams = res["teamInfos"]["nodes"]
+    member_teams = [x["team"] for x in res["teamMembers"]["nodes"]]
+
+    owned_org_teams = [x["teamInfosByOrgId"]["nodes"] for x in res["orgInfos"]["nodes"]]
+    owned_org_teams = list(itertools.chain(*owned_org_teams))
+
+    member_org_teams = [
+        x["org"]["teamInfosByOrgId"]["nodes"] for x in res["orgMembers"]["nodes"]
+    ]
+    member_org_teams = list(itertools.chain(*member_org_teams))
+
+    default_account = (
+        res["userInfoByAccountId"]["defaultAccount"]
+        if res["userInfoByAccountId"] is not None
+        else None
+    )
+    teams = {
+        x["accountId"]: WSInfo(
+            workspace_id=x["accountId"],
+            name=x["displayName"],
+            default=x["accountId"] == default_account,
+        )
+        for x in owned_teams
+        + member_teams
+        + (
+            [res["teamInfoByAccountId"]]
+            if res["teamInfoByAccountId"] is not None
+            else []
+        )
+        + owned_org_teams
+        + member_org_teams
+    }
+
+    return teams
+
+
+def current_workspace() -> str:
+    """Retrieves the current workspace ID based on the user's configuration.
+
+    If the workspace ID is not set, it retrieves the default workspace ID from the user's account.
+    If the default workspace ID is not set, it raises a ValueError.
+    """
+    ws = user_config.workspace_id
+    if ws == "":
+        res = execute(
+            gql.gql(
+                """
+                query DefaultAccountQuery {
+                    accountInfoCurrent {
+                        id
+                        user {
+                            defaultAccount
+                        }
+                    }
+                }
+            """
+            ),
+        )["accountInfoCurrent"]
+
+        default_ws = res["id"]
+
+        is_local = os.environ.get("FLYTE_INTERNAL_EXECUTION_ID") is None
+        if is_local and res["user"] is not None:
+            default_ws = res["user"]["defaultAccount"]
+
+        if default_ws is not None:
+            ws = default_ws
+
+    return ws

latch-2.45.3/latch.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.1
+Name: latch
+Version: 2.45.3
+Summary: The Latch SDK
+Author-email: kenny@latch.bio
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8,<3.12
+Provides-Extra: snakemake
+Provides-Extra: pandas
+License-File: LICENSE

{latch-2.45.2.dev2 → latch-2.45.3}/latch.egg-info/SOURCES.txt

@@ -80,10 +80,6 @@ latch_cli/exceptions/cache.py
 latch_cli/exceptions/errors.py
 latch_cli/exceptions/handler.py
 latch_cli/exceptions/traceback.py
-latch_cli/nextflow/__init__.py
-latch_cli/nextflow/dependencies.py
-latch_cli/nextflow/utils.py
-latch_cli/nextflow/workflow.py
 latch_cli/services/__init__.py
 latch_cli/services/get.py
 latch_cli/services/get_executions.py
@@ -110,8 +106,8 @@ latch_cli/services/execute/main.py
 latch_cli/services/execute/utils.py
 latch_cli/services/init/__init__.py
 latch_cli/services/init/init.py
-latch_cli/services/init/__pycache__/__init__.cpython-310.pyc
-latch_cli/services/init/__pycache__/init.cpython-310.pyc
+latch_cli/services/init/__pycache__/__init__.cpython-311.pyc
+latch_cli/services/init/__pycache__/init.cpython-311.pyc
 latch_cli/services/init/assemble_and_sort/.env
 latch_cli/services/init/assemble_and_sort/LICENSE
 latch_cli/services/init/assemble_and_sort/README.md

{latch-2.45.2.dev2 → latch-2.45.3}/latch_cli/centromere/ctx.py

@@ -59,7 +59,6 @@ class _CentromereCtx:
     default_container: _Container
     workflow_type: WorkflowType
     snakefile: Optional[Path]
-    nf_script: Optional[Path]
 
     latch_register_api_url = config.api.workflow.register
     latch_image_api_url = config.api.workflow.upload_image
@@ -81,7 +80,6 @@ class _CentromereCtx:
         disable_auto_version: bool = False,
         remote: bool = False,
         snakefile: Optional[Path] = None,
-        nf_script: Optional[Path] = None,
         use_new_centromere: bool = False,
     ):
         self.use_new_centromere = use_new_centromere
@@ -95,22 +93,13 @@ class _CentromereCtx:
             self.dkr_repo = config.dkr_repo
             self.pkg_root = pkg_root.resolve()
 
-            if snakefile and nf_script:
-                raise ValueError(
-                    "Cannot provide both a snakefile and nextflow script to the"
-                    " register command."
-                )
-            if snakefile is not None:
+            if snakefile is None:
+                self.workflow_type = WorkflowType.latchbiosdk
+            else:
                 self.workflow_type = WorkflowType.snakemake
                 self.snakefile = snakefile
-            elif nf_script is not None:
-                self.workflow_type = WorkflowType.nextflow
-                self.nf_script = nf_script
-            else:
-                self.workflow_type = WorkflowType.latchbiosdk
 
             self.container_map: Dict[str, _Container] = {}
-
             if self.workflow_type == WorkflowType.latchbiosdk:
                 _import_flyte_objects([self.pkg_root])
                 for entity in FlyteEntities.entities:
@@ -137,7 +126,11 @@ class _CentromereCtx:
                         fg="red",
                     )
                     raise click.exceptions.Exit(1)
-            elif self.workflow_type == WorkflowType.snakemake:
+
+                name_path = pkg_root / latch_constants.pkg_workflow_name
+                if name_path.exists():
+                    self.workflow_name = name_path.read_text().strip()
+            else:
                 assert snakefile is not None
 
                 import latch.types.metadata as metadata
@@ -149,10 +142,6 @@ class _CentromereCtx:
                 )
                 from ..snakemake.utils import load_snakemake_metadata
 
-                name_path = pkg_root / latch_constants.pkg_workflow_name
-                if name_path.exists():
-                    self.workflow_name = name_path.read_text().strip()
-
                 meta_file = load_snakemake_metadata(pkg_root)
                 if meta_file is not None:
                     click.echo(
@@ -246,32 +235,6 @@ class _CentromereCtx:
                 # todo(kenny): support per container task and custom workflow
                 # name for snakemake
                 self.workflow_name = f"{metadata._snakemake_metadata.name}_jit_register"
-            else:
-                assert nf_script is not None
-
-                import latch.types.metadata as metadata
-
-                from ..services.register.utils import import_module_by_path
-
-                meta = pkg_root / "latch_metadata" / "__init__.py"
-                if meta.exists():
-                    click.echo(f"Using metadata file {click.style(meta, italic=True)}")
-                    import_module_by_path(meta)
-
-                if metadata._nextflow_metadata is None:
-                    click.secho(
-                        dedent("""
-                        Failed to register Nextflow workflow.
-                        Make sure the project root contains a `latch_metadata/__init__.py`
-                        with a `NextflowMetadata` object defined.
-                        """),
-                        fg="red",
-                    )
-                    raise click.exceptions.Exit(1)
-
-                self.workflow_name = metadata._nextflow_metadata.name
-
-            assert self.workflow_name is not None
 
             version_file = self.pkg_root / "version"
             try: