latch 2.76.5__tar.gz → 2.76.7__tar.gz

{latch-2.76.5 → latch-2.76.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: latch
-Version: 2.76.5
+Version: 2.76.7
 Summary: The Latch SDK
 Project-URL: Homepage, https://latch.bio
 Project-URL: Documentation, https://latch.wiki
@@ -52,7 +52,7 @@ Requires-Dist: gql==3.5.0
 Requires-Dist: graphql-core==3.2.3
 Requires-Dist: kubernetes>=24.2.0
 Requires-Dist: latch-persistence>=0.1.5
-Requires-Dist: lytekit==0.16
+Requires-Dist: lytekit<0.17,>=0.16
 Requires-Dist: lytekitplugins-pods==0.7.4
 Requires-Dist: orjson>=3.10.12
 Requires-Dist: paramiko>=3.4.0

{latch-2.76.5 → latch-2.76.7}/pyproject.toml

@@ -12,7 +12,7 @@ include = ["src/**/*.py", "src/**/*.graphql", "src/**/py.typed", "src/latch_cli/
 
 [project]
 name = "latch"
-version = "2.76.5"
+version = "2.76.7"
 description = "The Latch SDK"
 authors = [{ name = "Kenny Workman", email = "kenny@latch.bio" }]
 maintainers = [{ name = "Kenny Workman", email = "kenny@latch.bio" }]
@@ -31,7 +31,7 @@ dependencies = [
   "scp>=0.14.0",
   "boto3>=1.26.0",
   "tqdm>=4.63.0",
-  "lytekit==0.16",
+  "lytekit>=0.16,<0.17",
   "lytekitplugins-pods==0.7.4",
   "typing-extensions>=4.12.0",
   "apscheduler>=3.10.0",
@@ -247,6 +247,10 @@ ignore = [
   "PLC1901",
 ]
 
+[tool.ruff.lint.pyupgrade]
+# Pydantic resolves annotations at runtime, where PEP 604 is unsupported on Python 3.9.
+keep-runtime-typing = true
+
 [tool.ruff.format]
 preview = true
 skip-magic-trailing-comma = true

{latch-2.76.5 → latch-2.76.7}/src/latch/resources/launch_plan.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import base64
-from typing import Any
+from typing import Any, Optional
 
 from flytekit.core.launch_plan import LaunchPlan as _LaunchPlan
 from flytekit.core.workflow import PythonFunctionWorkflow
@@ -41,7 +41,7 @@ class LaunchPlan:
         name: str,
         default_params: dict[str, Any],
         *,
-        description: str | None = None,
+        description: Optional[str] = None,
     ):
         labels = {}
         if description is not None:

{latch-2.76.5 → latch-2.76.7}/src/latch_cli/services/k8s/develop.py

@@ -306,7 +306,7 @@ def local_development(
     *,
     size: InstanceSize,
     skip_confirm_dialog: bool,
-    wf_version: str | None,
+    wf_version: Optional[str],
     disable_sync: bool,
 ):
     if not disable_sync:

{latch-2.76.5 → latch-2.76.7}/src/latch_cli/services/launch/type_converter.py

@@ -2,7 +2,7 @@ import dataclasses
 from dataclasses import asdict, is_dataclass
 from datetime import datetime, timedelta
 from enum import Enum
-from typing import Any
+from typing import Any, Optional
 
 from flytekit.models import literals as _literals
 from flytekit.models import types as _types
@@ -59,7 +59,7 @@ def _convert_primitive(
     if simple_type == _types.SimpleType.STRUCT:  # pyright: ignore[reportUnnecessaryComparison]
         return _convert_to_struct(value)
 
-    primitive: _literals.Primitive | None = None
+    primitive: Optional[_literals.Primitive] = None
 
     if simple_type == _types.SimpleType.INTEGER:  # pyright: ignore[reportUnnecessaryComparison]
         if isinstance(value, Enum):
@@ -243,7 +243,7 @@ def _convert_blob(
     blob_type: _core_types.BlobType,
 ) -> _literals.Literal:
 
-    remote_uri: str | None = None
+    remote_uri: Optional[str] = None
     if isinstance(value, (LatchFile, LatchDir)):
         remote_uri = value.remote_path if value.remote_path is not None else value.path
     elif isinstance(value, LPath):

{latch-2.76.5 → latch-2.76.7}/src/latch_cli/services/pods.py

@@ -5,7 +5,7 @@ import os
 import shlex
 import time
 from importlib import resources
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import urljoin
 
 import click
@@ -46,20 +46,20 @@ pod_ssh_starting_statuses = {
 class CreatePodRequest(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    ws_account_id: str | None = Field(
+    ws_account_id: Optional[str] = Field(
         default=None, json_schema_extra={"default_description": "current workspace"}
     )
     display_name: str = Field(..., json_schema_extra={"template": "My Pod"})
     cpu: int = Field(..., json_schema_extra={"template": 2, "units": "cores"})
     memory: int = Field(..., json_schema_extra={"template": 8, "units": "GiB"})
     gpu: int = Field(default=0, json_schema_extra={"template": 0})
-    gpu_type: Literal["nvidia-a10g", "nvidia-l40s"] | None = Field(
+    gpu_type: Optional[Literal["nvidia-a10g", "nvidia-l40s"]] = Field(
         default=None, json_schema_extra={"template": None}
     )
     storage_gigs: int = Field(
         default=20, json_schema_extra={"template": 20, "units": "GiB"}
     )
-    backup_interval: Literal["daily", "weekly", "monthly"] | None = Field(
+    backup_interval: Optional[Literal["daily", "weekly", "monthly"]] = Field(
         default=None, json_schema_extra={"template": None}
     )
     target_region: Literal["us-west-2", "us-east-1", "eu-central-1", "eu-west-1"] = (
@@ -105,7 +105,7 @@ class PodInfosResponse(BaseModel):
 
 
 class PodSshResponse(BaseModel):
-    pod_info: dict[str, Any] | None = Field(alias="podInfo")
+    pod_info: Optional[dict[str, Any]] = Field(alias="podInfo")
 
 
 def pod_list_fields(*, detailed: bool) -> list[str]:
@@ -295,8 +295,8 @@ def _format_pod_status(status: str) -> str:
 
 
 def _get_pod_ssh_args(
-    pod_id: int, pod: dict[str, object], *, key: Path | None = None
-) -> list[str] | None:
+    pod_id: int, pod: dict[str, object], *, key: Optional[Path] = None
+) -> Optional[list[str]]:
     deployment = pod.get("deployment")
     if not isinstance(deployment, dict):
         click.secho("Pod deployment information is unavailable.", fg="red")
@@ -331,7 +331,7 @@ def ssh_pod(
     pod_id: int,
     *,
     print_only: bool = False,
-    key: Path | None = None,
+    key: Optional[Path] = None,
     poll_interval_seconds: float = pod_ssh_poll_interval_seconds,
     max_wait_seconds: float = pod_ssh_max_wait_seconds,
     exec_fn: Callable[[str, list[str]], object] = os.execvp,

{latch-2.76.5 → latch-2.76.7}/src/latch_cli/services/register/register.py

@@ -62,6 +62,17 @@ def _print_window(cur_lines: List[str], line: str):
 docker_build_step_pat = re.compile("^Step [0-9]+/[0-9]+ :")
 
 
+def _replace_task_protos(
+    protos: List[Path], new_protos: List[Path], task_name: str
+) -> List[Path]:
+    """Replace a task's default-image protobuf with its custom-image version."""
+    new_task_protos = {
+        proto.name: proto for proto in new_protos if task_name in proto.name
+    }
+
+    return [new_task_protos.get(proto.name, proto) for proto in protos]
+
+
 def print_and_write_build_logs(
     build_logs: Iterable[DockerBuildLogItem],
     image: str,
@@ -581,22 +592,7 @@ def register(
 
                     new_protos = _recursive_list(local_task_td)
 
-                    try:
-                        split_task_name = task_name.split(".")
-                        task_name = ".".join(
-                            split_task_name[split_task_name.index(ctx.wf_module) :]
-                        )
-                        for new_proto in new_protos:
-                            if task_name in new_proto.name:
-                                protos = [
-                                    new_proto if new_proto.name == f.name else f
-                                    for f in protos
-                                ]
-                    except ValueError as e:
-                        raise ValueError(
-                            f"Unable to match {task_name} to any of the protobuf files"
-                            f" in {new_protos}"
-                        ) from e
+                    protos = _replace_task_protos(protos, new_protos, task_name)
                 except TypeError as e:
                     raise ValueError(
                         "The path to your provided dockerfile ",

{latch-2.76.5 → latch-2.76.7}/src/latch_cli/services/workspace.py

@@ -19,7 +19,7 @@ def workspace(workspace_id: Optional[str] = None):
     """
     data = get_workspaces()
 
-    old_id: str | None
+    old_id: Optional[str]
     try:
         old_id = current_workspace()
     except NoWorkspaceSelectedError:

latch-2.76.5/src/latch_cli/services/launch.py

@@ -1,262 +0,0 @@
-"""Service to launch a workflow."""
-
-import importlib.util
-import typing
-from pathlib import Path
-from typing import Optional, Tuple, Union
-
-import google.protobuf.json_format as gpjson
-import requests
-from flyteidl.core.types_pb2 import LiteralType
-from flytekit.core.context_manager import FlyteContextManager
-from flytekit.core.type_engine import TypeEngine
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
-
-from latch.utils import current_workspace, retrieve_or_login
-from latch_sdk_config.latch import config
-
-
-def launch(params_file: Path, version: Optional[str] = None) -> str:
-    """Launches a (versioned) workflow with parameters specified in python.
-
-    Using a parameter map written in python (this can be generated for you with
-    `get_params`), this function will launch the workflow specified in the file
-    using the parameters therein. This function also accepts an optional
-    `version` parameter to further specify the workflow to be run. If it is not
-    provided, this function will default to running the latest version of the
-    specified workflow.
-
-    Args:
-        params_file: A path pointing to a python parameter file containing a
-            function call that represents the workflow execution with valid
-            parameter values.
-        version: An optional workflow version to launch, defaulting to the
-            latest if not provided.
-
-    Returns:
-        The name of the workflow.
-
-    Example:
-        >>> launch(Path("wf.__init__.assemble_and_sort.params.py"))
-            # Launches an execution of `wf.__init__.assemble_and_sort` with the
-            # parameters specified in the referenced file.
-    """
-
-    token = retrieve_or_login()
-
-    with open(params_file) as pf:
-        param_code = pf.read()
-        spec = importlib.util.spec_from_loader("wf_params", loader=None)
-        param_module = importlib.util.module_from_spec(spec)
-        exec(param_code, param_module.__dict__)
-
-    module_vars = vars(param_module)
-    try:
-        wf_params = module_vars["params"]
-    except KeyError as e:
-        raise ValueError(
-            f"Execution file {params_file.name} needs to have"
-            " a parameter value dictionary named 'params'"
-        ) from e
-
-    wf_name = wf_params.get("_name")
-    if wf_name is None:
-        raise ValueError(
-            "The dictionary of parameters in the launch file lacks the"
-            " _name key used to identify the workflow. Make sure a _name"
-            " key with the workflow name exists in the dictionary."
-        )
-
-    wf_id, wf_interface, _ = _get_workflow_interface(token, wf_name, version)
-
-    wf_vars = wf_interface["variables"]
-    wf_literals = {}
-    for key, value in wf_vars.items():
-        ctx = FlyteContextManager.current_context()
-        literal_type_json = value["type"]
-        literal_type = gpjson.ParseDict(literal_type_json, LiteralType())
-
-        if key in wf_params:
-            python_value = wf_params[key]
-            # Recover parameterized generics for TypeTransformer.
-            python_type = _guess_python_type(python_value)
-
-            python_type_literal = TypeEngine.to_literal(
-                ctx, python_value, python_type, literal_type
-            )
-
-            wf_literals[key] = gpjson.MessageToDict(python_type_literal.to_flyte_idl())
-
-    _launch_workflow(token, wf_id, wf_literals)
-    return wf_name
-
-
-def _guess_python_type(v: any) -> typing.T:
-    """Python literal guesser.
-
-    We will attempt to construct the correct python type representation from the
-    value and JSON type representation and rely on the TypeTransformer to produce
-    the correct flyte literal for execution (FlyteIDL representation of the value).
-    This is essentially how flytekit does it.
-
-    Using the type() function alone is not sufficient because flyte interprets
-    the python list literal as a generic collection type and needs a
-    parameterization.
-
-    For example:
-
-    ..
-       >> type(["AUG", "AAA"]) = list
-       <class 'list'>
-
-    Becomes List[str] s.t.
-
-    ..
-       >> TypeEngine.to_literal(ctx, ["AUG", "AAA"], List[str], type_literal)
-
-    Returns our desired flyte literal.
-    """
-
-    if type(v) is list:
-        if len(v) == 0:
-            return typing.List[None]
-        if type(v[0]) is list:
-            return typing.List[_guess_python_type(v[0])]
-        return typing.List[type(v[0])]
-
-    # TODO: maps, Records, future complex types
-
-    return type(v)
-
-
-def _get_workflow_interface(
-    token: str, wf_name: str, version: Union[None, str]
-) -> Tuple[int, dict]:
-    """Retrieves the set of idl parameter values for a given workflow by name.
-
-    Returns workflow id + interface as JSON string.
-    """
-
-    headers = {"Authorization": f"Bearer {token}"}
-    _interface_request = {
-        "workflow_name": wf_name,
-        "version": version,
-        "ws_account_id": current_workspace(),
-    }
-
-    url = config.api.workflow.interface
-
-    # TODO(ayush) - figure out why timeout within this endpoint only.
-    session = requests.Session()
-    retries = 5
-    retry = Retry(total=retries, read=retries, connect=retries, method_whitelist=False)
-    adapter = HTTPAdapter(max_retries=retry)
-    session.mount("http://", adapter)
-    session.mount("https://", adapter)
-
-    response = session.post(url, headers=headers, json=_interface_request)
-
-    wf_interface_resp = response.json()
-
-    wf_id, wf_interface, wf_default_params = (
-        wf_interface_resp.get("id"),
-        wf_interface_resp.get("interface"),
-        wf_interface_resp.get("default_params"),
-    )
-    if wf_interface is None:
-        raise ValueError(
-            "Could not find interface. Nucleus returned a malformed JSON response -"
-            f" {wf_interface_resp}"
-        )
-    if wf_id is None:
-        raise ValueError(
-            "Could not find wf ID. Nucleus returned a malformed JSON response -"
-            f" {wf_interface_resp}"
-        )
-    if wf_default_params is None:
-        raise ValueError(
-            "Could not find wf default parameters. Nucleus returned a malformed JSON"
-            f" response - {wf_interface_resp}"
-        )
-
-    return int(wf_id), wf_interface, wf_default_params
-
-
-def _launch_workflow(token: str, wf_id: str, params: dict) -> bool:
-    """Launch the workflow of given id with parameter map.
-
-    Return True if success, raises appropriate exceptions on failure.
-    """
-    # Server sometimes stalls on requests with python user-agent
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "User-Agent": (
-            "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like"
-            " Gecko) Chrome/72.0.3626.119 Safari/537.36"
-        ),
-    }
-
-    _interface_request = {
-        "workflow_id": str(wf_id),
-        "params": params,
-        "ws_account_id": current_workspace(),
-    }
-    url = config.api.execution.create
-
-    response = requests.post(url, headers=headers, json=_interface_request)
-    response_data = response.json()
-
-    def extract_error_message(data: dict) -> str:
-        if "error" in data:
-            error = data["error"]
-            source = error.get("source", "unknown")
-
-            error_data = error.get("data", {})
-            message = (
-                error_data.get("stderr") or error_data.get("message") or str(error_data)
-            )
-
-            if isinstance(message, str):
-                error_lines = [line for line in message.split("\n") if "Error:" in line]
-                if error_lines:
-                    message = error_lines[-1].replace("Error:", "").strip()
-
-            return f"({source}): {message}"
-        return str(data)
-
-    if response.status_code != 200:
-        print("\nRaw server response:")
-        print(response_data)
-
-    if response.status_code == 403:
-        raise PermissionError(
-            "You need access to the latch sdk beta ~ join the waitlist @"
-            " https://latch.bio/sdk"
-        )
-    if response.status_code == 401:
-        raise ValueError(
-            "your token has expired - please run latch login to refresh your token and"
-            " try again."
-        )
-    if response.status_code == 429:
-        error_msg = extract_error_message(response_data)
-        print(f"\nFormatted error message: {error_msg}")
-        raise RuntimeError(f"Rate limit reached - {error_msg}")
-    if response.status_code == 400:
-        error_msg = extract_error_message(response_data)
-        print(f"\nFormatted error message: {error_msg}")
-        raise ValueError(f"Workflow launch failed - {error_msg}")
-    if response.status_code != 200:
-        error_msg = extract_error_message(response_data)
-        print(f"\nFormatted error message: {error_msg}")
-        raise RuntimeError(f"Server error (HTTP {response.status_code}) - {error_msg}")
-    if (
-        "error" in response_data
-        or response_data.get("status") != "Successfully launched workflow"
-    ):
-        error_msg = extract_error_message(response_data)
-        print(f"\nFormatted error message: {error_msg}")
-        raise RuntimeError(f"Workflow launch failed - {error_msg}")
-
-    return True