flyte 0.0.1b0__py3-none-any.whl → 2.0.0b46__py3-none-any.whl

flyte/_utils/uv_script_parser.py

@@ -1,6 +1,7 @@
 import pathlib
 import re
 from dataclasses import dataclass, field
+from functools import lru_cache
 from typing import Dict, List, Optional
 
 import toml
@@ -15,6 +16,7 @@ class ToolUVConfig:
 class UVScriptMetadata:
     requires_python: Optional[str] = None
     dependencies: List[str] = field(default_factory=list)
+    pyprojects: List[str] = field(default_factory=list)
     tool: Optional[Dict[str, ToolUVConfig]] = None
 
 
@@ -27,6 +29,7 @@ def _extract_uv_metadata_block(text: str) -> str | None:
     return "\n".join(lines)
 
 
+@lru_cache
 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}")
@@ -42,8 +45,12 @@ def parse_uv_script_file(path: pathlib.Path) -> UVScriptMetadata:
         raise ValueError(f"Invalid TOML in metadata block: {e}")
 
     tool_data = data.get("tool", {}).get("uv", {})
+    dependencies = data.get("dependencies", [])
+    py_dependencies = [dep for dep in dependencies if "file://" not in dep]
+    pyprojects = [dep.split("file://")[-1] for dep in dependencies if "file://" in dep]
     return UVScriptMetadata(
         requires_python=data.get("requires-python"),
-        dependencies=data.get("dependencies", []),
+        dependencies=py_dependencies,
+        pyprojects=pyprojects,
         tool={"uv": ToolUVConfig(exclude_newer=tool_data.get("exclude-newer"))} if tool_data else None,
     )

flyte/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     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 = '0.0.1b0'
-__version_tuple__ = version_tuple = (0, 0, 1, 'b0')
+__version__ = version = '2.0.0b46'
+__version_tuple__ = version_tuple = (2, 0, 0, 'b46')
+
+__commit_id__ = commit_id = 'g9b41862a0'

flyte/app/__init__.py

@@ -0,0 +1,27 @@
+from flyte.app._app_environment import AppEnvironment
+from flyte.app._connector_environment import ConnectorEnvironment
+from flyte.app._parameter import AppEndpoint, Parameter, RunOutput, get_parameter
+from flyte.app._types import Domain, Link, Port, Scaling
+
+__all__ = [
+    "AppEndpoint",
+    "AppEnvironment",
+    "ConnectorEnvironment",
+    "Domain",
+    "Link",
+    "Parameter",
+    "Port",
+    "RunOutput",
+    "Scaling",
+    "get_parameter",
+]
+
+
+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,362 @@
+from __future__ import annotations
+
+import inspect
+import os
+import re
+import shlex
+from dataclasses import dataclass, field, replace
+from typing import TYPE_CHECKING, Any, Callable, List, Literal, Optional, Union
+
+import rich.repr
+
+from flyte import Environment, Image, Resources, SecretRequest
+from flyte.app._parameter import Parameter
+from flyte.app._types import Domain, Link, Port, Scaling
+from flyte.models import SerializationContext
+
+if TYPE_CHECKING:
+    pass
+
+
+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 type: Type of the environment.
+    :param port: Port to use for the app server.
+    :param args: Arguments to pass to app.
+    :param command: Command to run in the app.
+    :param requires_auth: Whether the app requires authentication.
+    :param scaling: Scaling configuration for the app environment.
+    :param domain: Domain to use for the app.
+    :param links: Links to other environments.
+    :param include: Files to include in the environment to run the app.
+    :param parameters: Parameters to pass to the app environment.
+    :param cluster_pool: Cluster pool to use for the app environment.
+    :param name: Name of the app 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)
+    parameters: List[Parameter] = field(default_factory=list)
+
+    # queue / cluster_pool
+    cluster_pool: str = "default"
+
+    # private field
+    _server: Callable[[], None] | None = field(init=False, default=None)
+    _on_startup: Callable[[], None] | None = field(init=False, default=None)
+    _on_shutdown: Callable[[], None] | None = field(init=False, default=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 _get_app_filename(self) -> str:
+        """
+        Get the filename of the file that declares this app environment.
+
+        Returns the actual file path instead of <string>, skipping flyte SDK internal files.
+        """
+
+        def is_user_file(filename: str) -> bool:
+            """Check if a file is a user file (not part of flyte SDK)."""
+            if filename in ("<string>", "<stdin>"):
+                return False
+            if not os.path.exists(filename):
+                return False
+            # Skip files that are part of the flyte SDK
+            abs_path = os.path.abspath(filename)
+            # Check if file is in flyte package
+            return ("site-packages/flyte" not in abs_path and "/flyte/" not in abs_path) or "/examples/" in abs_path
+
+        # Try frame inspection first - walk up the stack to find user file
+        frame = inspect.currentframe()
+        while frame is not None:
+            filename = frame.f_code.co_filename
+            if is_user_file(filename):
+                return os.path.abspath(filename)
+            frame = frame.f_back
+
+        # Fallback: Inspect the full stack to find the first user file
+        stack = inspect.stack()
+        for frame_info in stack:
+            filename = frame_info.filename
+            if is_user_file(filename):
+                return os.path.abspath(filename)
+
+        # Last fallback: Try to get from __main__ module
+        import sys
+
+        if hasattr(sys.modules.get("__main__"), "__file__"):
+            main_file = sys.modules["__main__"].__file__
+            if main_file and os.path.exists(main_file):
+                return os.path.abspath(main_file)
+
+        # Last resort: return the current working directory with a placeholder
+        # This shouldn't happen in normal usage
+        return os.path.join(os.getcwd(), "app.py")
+
+    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
+        self._app_filename = self._get_app_filename()
+
+        # Capture the frame where this environment was instantiated
+        # This helps us find the module where the app variable is defined
+        frame = inspect.currentframe()
+        if frame and frame.f_back:
+            # Go up the call stack to find the user's module
+            # Skip the dataclass __init__ frame
+            caller_frame = frame.f_back
+            if caller_frame and caller_frame.f_back:
+                self._caller_frame = inspect.getframeinfo(caller_frame.f_back)
+
+    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_parameters(self, parameter_overrides: list[Parameter] | None) -> str:
+        if not self.parameters:
+            return ""
+        from ._parameter import SerializableParameterCollection
+
+        serialized_parameters = SerializableParameterCollection.from_parameters(parameter_overrides or self.parameters)
+        return serialized_parameters.to_transport
+
+    def on_startup(self, fn: Callable[..., None]) -> Callable[..., None]:
+        """
+        Decorator to define the startup function for the app environment.
+
+        This function is called before the server function is called.
+
+        The decorated function can be a sync or async function, and accepts input
+        parameters based on the Parameters defined in the AppEnvironment
+        definition.
+        """
+        self._on_startup = fn
+        return self._on_startup
+
+    def server(self, fn: Callable[..., None]) -> Callable[..., None]:
+        """
+        Decorator to define the server function for the app environment.
+
+        This decorated function can be a sync or async function, and accepts input
+        parameters based on the Parameters defined in the AppEnvironment
+        definition.
+        """
+        self._server = fn
+        return self._server
+
+    def on_shutdown(self, fn: Callable[..., None]) -> Callable[..., None]:
+        """
+        Decorator to define the shutdown function for the app environment.
+
+        This function is called after the server function is called.
+
+        This decorated function can be a sync or async function, and accepts input
+        parameters based on the Parameters defined in the AppEnvironment
+        definition.
+        """
+        self._on_shutdown = fn
+        return self._on_shutdown
+
+    def container_cmd(
+        self, serialize_context: SerializationContext, parameter_overrides: list[Parameter] | None = None
+    ) -> List[str]:
+        from flyte._internal.resolvers.app_env import AppEnvResolver
+
+        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.parameters:
+                cmd.append("--parameters")
+                cmd.append(self._serialize_parameters(parameter_overrides))
+
+            # Only add resolver args if _caller_frame is set and we can extract the module
+            # (i.e., app was created in a module and can be found)
+            if self._caller_frame is not None:
+                assert serialize_context.root_dir is not None
+                try:
+                    _app_env_resolver = AppEnvResolver()
+                    loader_args = _app_env_resolver.loader_args(self, serialize_context.root_dir)
+                    cmd = [
+                        *cmd,
+                        *[
+                            "--resolver",
+                            _app_env_resolver.import_path,
+                            "--resolver-args",
+                            loader_args,
+                        ],
+                    ]
+                except RuntimeError as e:
+                    # If we can't find the app in the module (e.g., in tests), skip resolver args
+                    from flyte._logging import logger
+
+                    logger.warning(f"Failed to extract app resolver args: {e}. Skipping resolver args.")
+            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.format(app_fqdn=self.name)
+
+        import flyte.remote
+        from flyte._initialize import ensure_client
+
+        ensure_client()
+        app = flyte.remote.App.get(name=self.name)
+        return app.endpoint
+
+    def clone_with(
+        self,
+        name: str,
+        image: Optional[Union[str, Image, Literal["auto"]]] = None,
+        resources: Optional[Resources] = None,
+        env_vars: Optional[dict[str, str]] = None,
+        secrets: Optional[SecretRequest] = None,
+        depends_on: Optional[List[Environment]] = None,
+        description: Optional[str] = None,
+        interruptible: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> AppEnvironment:
+        # validate unknown kwargs if needed
+
+        type = kwargs.pop("type", None)
+        port = kwargs.pop("port", None)
+        args = kwargs.pop("args", None)
+        command = kwargs.pop("command", None)
+        requires_auth = kwargs.pop("requires_auth", None)
+        scaling = kwargs.pop("scaling", None)
+        domain = kwargs.pop("domain", None)
+        links = kwargs.pop("links", None)
+        include = kwargs.pop("include", None)
+        parameters = kwargs.pop("parameters", None)
+        cluster_pool = kwargs.pop("cluster_pool", None)
+
+        if kwargs:
+            raise TypeError(f"Unexpected keyword arguments: {list(kwargs.keys())}")
+
+        kwargs = self._get_kwargs()
+        kwargs["name"] = name
+        if image is not None:
+            kwargs["image"] = image
+        if resources is not None:
+            kwargs["resources"] = resources
+        if env_vars is not None:
+            kwargs["env_vars"] = env_vars
+        if secrets is not None:
+            kwargs["secrets"] = secrets
+        if depends_on is not None:
+            kwargs["depends_on"] = depends_on
+        if description is not None:
+            kwargs["description"] = description
+        if type is not None:
+            kwargs["type"] = type
+        if port is not None:
+            kwargs["port"] = port
+        if args is not None:
+            kwargs["args"] = args
+        if command is not None:
+            kwargs["command"] = command
+        if requires_auth is not None:
+            kwargs["requires_auth"] = requires_auth
+        if scaling is not None:
+            kwargs["scaling"] = scaling
+        if domain is not None:
+            kwargs["domain"] = domain
+        if links is not None:
+            kwargs["links"] = links
+        if include is not None:
+            kwargs["include"] = include
+        if parameters is not None:
+            kwargs["parameters"] = parameters
+        if cluster_pool is not None:
+            kwargs["cluster_pool"] = cluster_pool
+        return replace(self, **kwargs)

flyte/app/_connector_environment.py

@@ -0,0 +1,40 @@
+import shlex
+from dataclasses import dataclass, field
+from typing import List
+
+import rich.repr
+
+from flyte.app import AppEnvironment
+from flyte.app._parameter import Parameter
+from flyte.app._types import Port
+from flyte.models import SerializationContext
+
+
+@rich.repr.auto
+@dataclass(init=True, repr=True)
+class ConnectorEnvironment(AppEnvironment):
+    type: str = "Connector"
+    port: int | Port = field(default=Port(port=8080, name="h2c"))
+
+    def __post_init__(self):
+        super().__post_init__()
+
+    def container_args(self, serialize_context: SerializationContext) -> List[str]:
+        if self.args is None:
+            if isinstance(self.port, Port):
+                port = self.port.port
+            else:
+                port = self.port
+            return ["c0", "--port", str(port), "--prometheus_port", "9092"]
+        return super().container_args(serialize_context)
+
+    def container_cmd(
+        self, serialize_context: SerializationContext, parameter_overrides: list[Parameter] | None = None
+    ) -> List[str]:
+        if isinstance(self.command, str):
+            return shlex.split(self.command)
+        elif isinstance(self.command, list):
+            return self.command
+        else:
+            # command is None, use default from parent class
+            return super().container_cmd(serialize_context, parameter_overrides)

flyte/app/_deploy.py

@@ -0,0 +1,130 @@
+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
+from flyte._logging import logger
+from flyte.models import SerializationContext
+
+from ._app_environment import AppEnvironment
+from ._parameter import Parameter
+
+if typing.TYPE_CHECKING:
+    from flyte._deployer import DeployedEnvironment
+    from flyte.remote import App
+
+FILES_TAR_FILE_NAME = "code_bundle.tgz"
+
+
+@dataclass
+class DeployedAppEnvironment:
+    env: AppEnvironment
+    deployed_app: "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", f"[link={self.deployed_app.url}]{self.deployed_app.name}[/link]"),
+                ("revision", str(self.deployed_app.revision)),
+                (
+                    "desired state",
+                    app_definition_pb2.Spec.DesiredState.Name(self.deployed_app.desired_state),
+                ),
+                (
+                    "current state",
+                    app_definition_pb2.Status.DeploymentStatus.Name(self.deployed_app.deployment_status),
+                ),
+                (
+                    "public_url",
+                    self.deployed_app.endpoint,
+                ),
+            ],
+        ]
+
+    def summary_repr(self) -> str:
+        return f"Deployed App[{self.deployed_app.name}] in environment {self.env.name}"
+
+
+async def _deploy_app(
+    app: AppEnvironment,
+    serialization_context: SerializationContext,
+    parameter_overrides: list[Parameter] | None = None,
+    dryrun: bool = False,
+) -> "App":
+    """
+    Deploy the given app.
+    """
+    import flyte.errors
+    from flyte.app._runtime import translate_app_env_to_idl
+    from flyte.remote import App
+
+    is_pkl = serialization_context.code_bundle and serialization_context.code_bundle.pkl
+    if app.include and not is_pkl:
+        # Only bundle when not pickling. If this is a pkl bundle, assume that
+        # the AppEnvironment has a server function that will be used to serve
+        # the app. This function should contain all of the code needed to serve the app.
+        app_file = Path(app._app_filename)
+        app_root_dir = app_file.parent
+        _preexisting_code_bundle_files = []
+        if serialization_context.code_bundle is not None:
+            _preexisting_code_bundle_files = serialization_context.code_bundle.files or []
+        files = (*_preexisting_code_bundle_files, *[f for f in app.include if f not in _preexisting_code_bundle_files])
+        code_bundle = await build_code_bundle_from_relative_paths(files, from_dir=app_root_dir)
+        serialization_context.code_bundle = code_bundle
+
+    if serialization_context.code_bundle and serialization_context.code_bundle.pkl:
+        assert app._server is not None, (
+            "Server function is required for pkl code bundles, use the app_env.server() decorator to define the "
+            "server function."
+        )
+
+    image_uri = app.image.uri if isinstance(app.image, Image) else app.image
+    try:
+        app_idl = await translate_app_env_to_idl.aio(
+            app, serialization_context, parameter_overrides=parameter_overrides
+        )
+
+        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)
+
+        return await App.create.aio(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)