flyte 2.0.0b32__py3-none-any.whl

flyte/_utils/lazy_module.py

@@ -0,0 +1,54 @@
+import importlib.util
+import sys
+import types
+
+
+class _LazyModule(types.ModuleType):
+    """
+    `lazy_module` returns an instance of this class if the module is not found in the python environment.
+    """
+
+    def __init__(self, module_name: str):
+        super().__init__(module_name)
+        self._module_name = module_name
+
+    def __getattribute__(self, attr):
+        raise ImportError(f"Module {object.__getattribute__(self, '_module_name')} is not yet installed.")
+
+
+def is_imported(module_name):
+    """
+    This function is used to check if a module has been imported by the regular import.
+    Return false if module is lazy imported and not used yet.
+    """
+    return (
+        module_name in sys.modules
+        and object.__getattribute__(lazy_module(module_name), "__class__").__name__ != "_LazyModule"
+    )
+
+
+def lazy_module(fullname):
+    """
+    This function is used to lazily import modules.  It is used in the following way:
+    .. code-block:: python
+        from flytekit.lazy_import import lazy_module
+        sklearn = lazy_module("sklearn")
+        sklearn.svm.SVC()
+    :param Text fullname: The full name of the module to import
+    """
+    if fullname in sys.modules:
+        return sys.modules[fullname]
+    # https://docs.python.org/3/library/importlib.html#implementing-lazy-imports
+    spec = importlib.util.find_spec(fullname)
+    if spec is None or spec.loader is None:
+        # Return a lazy module if the module is not found in the python environment,
+        # so that we can raise a proper error when the user tries to access an attribute in the module.
+        # The reason to do this is because importlib.util.LazyLoader still requires
+        # the module to be installed even if you don't use it.
+        return _LazyModule(fullname)
+    loader = importlib.util.LazyLoader(spec.loader)
+    spec.loader = loader
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[fullname] = module
+    loader.exec_module(module)
+    return module

flyte/_utils/module_loader.py

@@ -0,0 +1,104 @@
+import glob
+import importlib.util
+import os
+import sys
+from pathlib import Path
+from typing import List, Tuple
+
+import flyte.errors
+from flyte._constants import FLYTE_SYS_PATH
+from flyte._logging import logger
+
+
+def load_python_modules(path: Path, recursive: bool = False) -> Tuple[List[str], List[Tuple[Path, str]]]:
+    """
+    Load all Python modules from a path and return list of loaded module names.
+
+    :param path: File or directory path
+    :param recursive: If True, load modules recursively from subdirectories
+    :return: List of loaded module names, and list of file paths that failed to load
+    """
+    from rich.progress import BarColumn, Progress, TextColumn, TimeElapsedColumn, TimeRemainingColumn
+
+    loaded_modules = []
+    failed_paths = []
+
+    if path.is_file() and path.suffix == ".py":
+        # Single file case
+        module_name = _load_module_from_file(path)
+        if module_name:
+            loaded_modules.append(module_name)
+
+    elif path.is_dir():
+        # Directory case
+        pattern = "**/*.py" if recursive else "*.py"
+        python_files = glob.glob(str(path / pattern), recursive=recursive)
+
+        with Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            "[progress.percentage]{task.percentage:>3.0f}%",
+            TimeElapsedColumn(),
+            TimeRemainingColumn(),
+            TextColumn("• {task.fields[current_file]}"),
+        ) as progress:
+            task = progress.add_task(f"Loading {len(python_files)} files", total=len(python_files), current_file="")
+            for file_path in python_files:
+                p = Path(file_path)
+                progress.update(task, advance=1, current_file=p.name)
+                # Skip __init__.py files
+                if p.name == "__init__.py":
+                    continue
+
+                try:
+                    module_name = _load_module_from_file(p)
+                    if module_name:
+                        loaded_modules.append(module_name)
+                except flyte.errors.ModuleLoadError as e:
+                    failed_paths.append((p, str(e)))
+
+            progress.update(task, advance=1, current_file="[green]Done[/green]")
+
+    return loaded_modules, failed_paths
+
+
+def _load_module_from_file(file_path: Path) -> str | None:
+    """
+    Load a Python module from a file path.
+
+    :param file_path: Path to the Python file
+    :return: Module name if successfully loaded, None otherwise
+    """
+    try:
+        # Use the file stem as module name
+        module_name = file_path.stem
+
+        # Load the module specification
+        spec = importlib.util.spec_from_file_location(module_name, file_path)
+        if spec is None or spec.loader is None:
+            return None
+
+        # Create and execute the module
+        module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+        module_path = os.path.dirname(os.path.abspath(file_path))
+        sys.path.append(module_path)
+        spec.loader.exec_module(module)
+
+        return module_name
+
+    except Exception as e:
+        raise flyte.errors.ModuleLoadError(f"Failed to load module from {file_path}: {e}") from e
+
+
+def adjust_sys_path():
+    """
+    Adjust sys.path to include local sys.path entries under the root directory.
+    """
+    if "." not in sys.path or os.getcwd() not in sys.path:
+        sys.path.insert(0, ".")
+        logger.info(f"Added {os.getcwd()} to sys.path")
+    for p in os.environ.get(FLYTE_SYS_PATH, "").split(":"):
+        if p and p not in sys.path:
+            sys.path.insert(0, p)
+            logger.info(f"Added {p} to sys.path")

flyte/_utils/org_discovery.py

@@ -0,0 +1,57 @@
+def hostname_from_url(url: str) -> str:
+    """Parse a URL and return the hostname part."""
+
+    # Handle dns:/// format specifically (gRPC convention)
+    if url.startswith("dns:///"):
+        return url[7:]  # Skip the "dns:///" prefix
+
+    # Handle standard URL formats
+    import urllib.parse
+
+    parsed = urllib.parse.urlparse(url)
+    return parsed.netloc or parsed.path.lstrip("/").rsplit("/")[0]
+
+
+def org_from_endpoint(endpoint: str | None) -> str | None:
+    """
+    Extracts the organization from the endpoint URL. The organization is assumed to be the first part of the domain.
+    This is temporary until we have a proper organization discovery mechanism through APIs.
+
+    :param endpoint: The endpoint URL
+    :return: The organization name or None if not found
+    """
+    if not endpoint:
+        return None
+
+    hostname = hostname_from_url(endpoint)
+    domain_parts = hostname.split(".")
+    if len(domain_parts) > 2:
+        # Assuming the organization is the first part of the domain
+        return domain_parts[0]
+    return None
+
+
+def sanitize_endpoint(endpoint: str | None) -> str | None:
+    """
+    Sanitize the endpoint URL by ensuring it has a valid scheme.
+    :param endpoint: The endpoint URL to sanitize
+    :return: Sanitized endpoint URL or None if the input was None
+    """
+    if not endpoint:
+        return None
+    if "://" not in endpoint:
+        endpoint = f"dns:///{endpoint}"
+    else:
+        if endpoint.startswith("https://"):
+            # If the endpoint starts with dns:///, we assume it's a gRPC endpoint
+            endpoint = f"dns:///{endpoint[8:]}"
+        elif endpoint.startswith("http://"):
+            # If the endpoint starts with http://, we assume it's a REST endpoint
+            endpoint = f"dns:///{endpoint[7:]}"
+        elif not endpoint.startswith("dns:///"):
+            raise RuntimeError(
+                f"Invalid endpoint {endpoint}, expected format is "
+                f"dns:///<hostname> or https://<hostname> or http://<hostname>"
+            )
+    endpoint = endpoint.removesuffix("/")
+    return endpoint

flyte/_utils/uv_script_parser.py

@@ -0,0 +1,49 @@
+import pathlib
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+import toml
+
+
+@dataclass
+class ToolUVConfig:
+    exclude_newer: Optional[str] = None
+
+
+@dataclass
+class UVScriptMetadata:
+    requires_python: Optional[str] = None
+    dependencies: List[str] = field(default_factory=list)
+    tool: Optional[Dict[str, ToolUVConfig]] = None
+
+
+def _extract_uv_metadata_block(text: str) -> str | None:
+    pattern = re.compile(r"# /// script\s*(.*?)# ///", re.DOTALL)
+    match = pattern.search(text)
+    if not match:
+        return None
+    lines = [line.lstrip("# ").rstrip() for line in match.group(1).splitlines()]
+    return "\n".join(lines)
+
+
+def parse_uv_script_file(path: pathlib.Path) -> UVScriptMetadata:
+    if not path.exists() or not path.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    text = path.read_text(encoding="utf-8")
+    raw_header = _extract_uv_metadata_block(text)
+    if raw_header is None:
+        raise ValueError("No uv metadata block found")
+
+    try:
+        data = toml.loads(raw_header)
+    except toml.TomlDecodeError as e:
+        raise ValueError(f"Invalid TOML in metadata block: {e}")
+
+    tool_data = data.get("tool", {}).get("uv", {})
+    return UVScriptMetadata(
+        requires_python=data.get("requires-python"),
+        dependencies=data.get("dependencies", []),
+        tool={"uv": ToolUVConfig(exclude_newer=tool_data.get("exclude-newer"))} if tool_data else None,
+    )

flyte/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '2.0.0b32'
+__version_tuple__ = version_tuple = (2, 0, 0, 'b32')
+
+__commit_id__ = commit_id = 'gc7251f82e'

flyte/app/__init__.py

@@ -0,0 +1,22 @@
+from flyte.app._app_environment import AppEnvironment
+from flyte.app._input import Input
+from flyte.app._types import Domain, Link, Port, Scaling
+
+__all__ = [
+    "AppEnvironment",
+    "Domain",
+    "Input",
+    "Link",
+    "Port",
+    "Scaling",
+]
+
+
+def register_app_deployer():
+    from flyte import _deployer as deployer
+    from flyte.app._deploy import _deploy_app_env
+
+    deployer.register_deployer(AppEnvironment, _deploy_app_env)
+
+
+register_app_deployer()

flyte/app/_app_environment.py

@@ -0,0 +1,157 @@
+import inspect
+import os
+import re
+import shlex
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+
+import rich.repr
+
+from flyte import Environment
+from flyte.app._input import Input
+from flyte.app._types import Domain, Link, Port, Scaling
+from flyte.models import SerializationContext
+
+APP_NAME_RE = re.compile(r"[a-z0-9]([-a-z0-9]*[a-z0-9])?(\\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*")
+INVALID_APP_PORTS = [8012, 8022, 8112, 9090, 9091]
+INTERNAL_APP_ENDPOINT_PATTERN_ENV_VAR = "INTERNAL_APP_ENDPOINT_PATTERN"
+
+
+@rich.repr.auto
+@dataclass(init=True, repr=True)
+class AppEnvironment(Environment):
+    """
+    :param name: Name of the environment
+    :param image: Docker image to use for the environment. If set to "auto", will use the default image.
+    :param resources: Resources to allocate for the environment.
+    :param env_vars: Environment variables to set for the environment.
+    :param secrets: Secrets to inject into the environment.
+    :param depends_on: Environment dependencies to hint, so when you deploy the environment, the dependencies are
+        also deployed. This is useful when you have a set of environments that depend on each other.
+    """
+
+    type: Optional[str] = None
+    port: int | Port = 8080
+    args: Optional[Union[List[str], str]] = None
+    command: Optional[Union[List[str], str]] = None
+    requires_auth: bool = True
+    scaling: Scaling = field(default_factory=Scaling)
+    domain: Domain | None = field(default_factory=Domain)
+    # Integration
+    links: List[Link] = field(default_factory=list)
+
+    # Code
+    include: List[str] = field(default_factory=list)
+    inputs: List[Input] = field(default_factory=list)
+
+    # queue / cluster_pool
+    cluster_pool: str = "default"
+
+    # config: Optional[AppConfigProtocol] = None
+
+    def _validate_name(self):
+        if not APP_NAME_RE.fullmatch(self.name):
+            raise ValueError(
+                f"App name '{self.name}' must consist of lower case alphanumeric characters or '-', "
+                "and must start and end with an alphanumeric character."
+            )
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.args is not None and not isinstance(self.args, (list, str)):
+            raise TypeError(f"Expected args to be of type List[str] or str, got {type(self.args)}")
+        if isinstance(self.port, int):
+            self.port = Port(port=self.port)  # Name should be blank can be h2c / http1
+            if self.port.port in INVALID_APP_PORTS:
+                raise ValueError(f"Port {self.port.port} is reserved and cannot be used for AppEnvironment")
+        if self.command is not None and not isinstance(self.command, (list, str)):
+            raise TypeError(f"Expected command to be of type List[str] or str, got {type(self.command)}")
+        if not isinstance(self.scaling, Scaling):
+            raise TypeError(f"Expected scaling to be of type Scaling, got {type(self.scaling)}")
+        if not isinstance(self.domain, (Domain, type(None))):
+            raise TypeError(f"Expected domain to be of type Domain or None, got {type(self.domain)}")
+        for link in self.links:
+            if not isinstance(link, Link):
+                raise TypeError(f"Expected links to be of type List[Link], got {type(link)}")
+
+        self._validate_name()
+
+        # get instantiated file to keep track of app root directory
+        frame = inspect.currentframe().f_back.f_back  # two frames up to get the app filename
+        self._app_filename = frame.f_code.co_filename
+
+    def container_args(self, serialize_context: SerializationContext) -> List[str]:
+        if self.args is None:
+            return []
+        elif isinstance(self.args, str):
+            return shlex.split(self.args)
+        else:
+            # args is a list
+            return self.args
+
+    def _serialize_inputs(self) -> str:
+        if not self.inputs:
+            return ""
+        from ._input import SerializableInputCollection
+
+        serialized_inputs = SerializableInputCollection.from_inputs(self.inputs)
+        return serialized_inputs.to_transport
+
+    def container_cmd(self, serialize_context: SerializationContext) -> List[str]:
+        if self.command is None:
+            # Default command
+            version = serialize_context.version
+            if version is None and serialize_context.code_bundle is not None:
+                version = serialize_context.code_bundle.computed_version
+
+            cmd: list[str] = [
+                "fserve",
+                "--version",
+                version or "",
+                "--project",
+                serialize_context.project or "",
+                "--domain",
+                serialize_context.domain or "",
+                "--org",
+                serialize_context.org or "",
+            ]
+
+            if serialize_context.image_cache and serialize_context.image_cache.serialized_form:
+                cmd = [*cmd, "--image-cache", serialize_context.image_cache.serialized_form]
+            else:
+                if serialize_context.image_cache:
+                    cmd = [*cmd, "--image-cache", serialize_context.image_cache.to_transport]
+
+            if serialize_context.code_bundle:
+                if serialize_context.code_bundle.tgz:
+                    cmd = [*cmd, *["--tgz", f"{serialize_context.code_bundle.tgz}"]]
+                elif serialize_context.code_bundle.pkl:
+                    cmd = [*cmd, *["--pkl", f"{serialize_context.code_bundle.pkl}"]]
+                cmd = [*cmd, *["--dest", f"{serialize_context.code_bundle.destination or '.'}"]]
+
+            if self.inputs:
+                cmd.append("--inputs")
+                cmd.append(self._serialize_inputs())
+
+            return [*cmd, "--"]
+        elif isinstance(self.command, str):
+            return shlex.split(self.command)
+        else:
+            # command is a list
+            return self.command
+
+    def get_port(self) -> Port:
+        if isinstance(self.port, int):
+            self.port = Port(port=self.port)
+        return self.port
+
+    @property
+    def endpoint(self) -> str:
+        endpoint_pattern = os.getenv(INTERNAL_APP_ENDPOINT_PATTERN_ENV_VAR)
+        if endpoint_pattern is not None:
+            return endpoint_pattern.replace("{app_fqdn}", self.name)
+
+        import flyte.remote
+
+        app = flyte.remote.App.get(name=self.name)
+        return app.endpoint

flyte/app/_deploy.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import typing
+from dataclasses import dataclass
+from pathlib import Path
+
+import flyte._deployer as deployer
+from flyte import Image
+from flyte._code_bundle.bundle import build_code_bundle_from_relative_paths
+from flyte._initialize import ensure_client, get_client
+from flyte._logging import logger
+from flyte.models import SerializationContext
+
+from ._app_environment import AppEnvironment
+
+if typing.TYPE_CHECKING:
+    from flyteidl2.app import app_definition_pb2
+
+    from flyte._deployer import DeployedEnvironment
+
+FILES_TAR_FILE_NAME = "code_bundle.tgz"
+
+
+@dataclass
+class DeployedAppEnvironment:
+    env: AppEnvironment
+    deployed_app: app_definition_pb2.App
+
+    def get_name(self) -> str:
+        """
+        Returns the name of the deployed environment.
+        """
+        return self.env.name
+
+    def env_repr(self) -> typing.List[typing.Tuple[str, ...]]:
+        return [
+            ("environment", self.env.name),
+            ("image", self.env.image.uri if isinstance(self.env.image, Image) else self.env.image or ""),
+        ]
+
+    def table_repr(self) -> typing.List[typing.List[typing.Tuple[str, ...]]]:
+        from flyteidl2.app import app_definition_pb2
+
+        return [
+            [
+                ("type", "App"),
+                ("name", self.deployed_app.metadata.id.name),
+                ("version", self.deployed_app.spec.runtime_metadata.version),
+                (
+                    "state",
+                    app_definition_pb2.Spec.DesiredState.Name(self.deployed_app.spec.desired_state),
+                ),
+                (
+                    "public_url",
+                    self.deployed_app.status.ingress.public_url,
+                ),
+            ],
+        ]
+
+    def summary_repr(self) -> str:
+        return f"Deployed App[{self.deployed_app.metadata.id.name}] in environment {self.env.name}"
+
+
+async def _deploy_app(
+    app: AppEnvironment, serialization_context: SerializationContext, dryrun: bool = False
+) -> app_definition_pb2.App:
+    """
+    Deploy the given app.
+    """
+    import grpc.aio
+    from flyteidl2.app import app_definition_pb2, app_payload_pb2
+
+    import flyte.errors
+    from flyte.app._runtime import translate_app_env_to_idl
+
+    if app.include:
+        app_file = Path(app._app_filename)
+        app_root_dir = app_file.parent
+        files = (app_file.name, *app.include)
+        code_bundle = await build_code_bundle_from_relative_paths(files, from_dir=app_root_dir)
+        serialization_context.code_bundle = code_bundle
+
+    image_uri = app.image.uri if isinstance(app.image, Image) else app.image
+    try:
+        app_idl = translate_app_env_to_idl(app, serialization_context)
+        if dryrun:
+            return app_idl
+        ensure_client()
+        msg = f"Deploying app {app.name}, with image {image_uri} version {serialization_context.version}"
+        if app_idl.spec.HasField("container") and app_idl.spec.container.args:
+            msg += f" with args {app_idl.spec.container.args}"
+        logger.info(msg)
+
+        try:
+            await get_client().app_service.Create(app_payload_pb2.CreateRequest(app=app_idl))
+            logger.info(f"Deployed app {app.name} with version {app_idl.spec.runtime_metadata.version}")
+        except grpc.aio.AioRpcError as e:
+            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
+                logger.warning(f"App {app.name} with image {image_uri} already exists, updating...")
+                resp = await get_client().app_service.Get(app_payload_pb2.GetRequest(app_id=app_idl.metadata.id))
+                # Update the revision to match the existing app
+                updated_app = app_definition_pb2.App(
+                    metadata=resp.app.metadata, spec=app_idl.spec, status=resp.app.status
+                )
+                logger.info(f"Updating app {app.name} to revision {updated_app.metadata.revision}")
+                update_resp = await get_client().app_service.Update(app_payload_pb2.UpdateRequest(app=updated_app))
+                return update_resp.app
+            raise
+
+        return app_idl
+    except Exception as exc:
+        logger.error(f"Failed to deploy app {app.name} with image {image_uri}: {exc}")
+        raise flyte.errors.DeploymentError(
+            f"Failed to deploy app {app.name} with image {image_uri}, Error: {exc!s}"
+        ) from exc
+
+
+async def _deploy_app_env(context: deployer.DeploymentContext) -> DeployedEnvironment:
+    if not isinstance(context.environment, AppEnvironment):
+        raise TypeError(f"Expected AppEnvironment, got {type(context.environment)}")
+
+    app_env = context.environment
+    deployed_app = await _deploy_app(app_env, context.serialization_context, dryrun=context.dryrun)
+
+    return DeployedAppEnvironment(env=app_env, deployed_app=deployed_app)