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

flyte/_secret.py

@@ -7,30 +7,30 @@ from typing import List, Optional, Union
 @dataclass
 class Secret:
     """
-    Secrets are used to inject sensitive information into tasks. Secrets can be mounted as environment variables or
-    files. The secret key is the name of the secret in the secret store. The group is optional and maybe used with some
-    secret stores to organize secrets. The secret_mount is used to specify how the secret should be mounted. If the
-    secret_mount is set to "env" the secret will be mounted as an environment variable. If the secret_mount is set to
-    "file" the secret will be mounted as a file. The as_env_var is an optional parameter that can be used to specify the
+    Secrets are used to inject sensitive information into tasks or image build context.
+    Secrets can be mounted as environment variables or files.
+     The secret key is the name of the secret in the secret store. The group is optional and maybe used with some
+    secret stores to organize secrets. The as_env_var is an optional parameter that can be used to specify the
     name of the environment variable that the secret should be mounted as.
 
     Example:
     ```python
-    @task(secrets="MY_SECRET")
+    @task(secrets="my-secret")
     async def my_task():
-        os.environ["MY_SECRET"]  # This will be set to the value of the secret
+        # This will be set to the value of the secret. Note: The env var is always uppercase, and - is replaced with _.
+        os.environ["MY_SECRET"]
 
-    @task(secrets=Secret("MY_SECRET", mount="/path/to/secret"))
+    @task(secrets=Secret("my-openai-api-key", as_env_var="OPENAI_API_KEY"))
     async def my_task2():
-        async with open("/path/to/secret") as f:
-            secret_value = f.read()
+        os.environ["OPENAI_API_KEY"]
     ```
 
     TODO: Add support for secret versioning (some stores) and secret groups (some stores) and mounting as files.
 
     :param key: The name of the secret in the secret store.
     :param group: The group of the secret in the secret store.
-    :param mount: Use this to specify the path where the secret should be mounted.
+    :param mount: For now, the only supported mount path is "/etc/flyte/secrets".
+    TODO: support arbitrary mount paths. Today only "/etc/flyte/secrets" is supported
     :param as_env_var: The name of the environment variable that the secret should be mounted as.
     """
 
@@ -40,11 +40,38 @@ class Secret:
     as_env_var: Optional[str] = None
 
     def __post_init__(self):
+        if not self.mount and not self.as_env_var:
+            self.as_env_var = f"{self.group}_{self.key}" if self.group else self.key
+            self.as_env_var = self.as_env_var.replace("-", "_").upper()
+        if self.mount:
+            if str(self.mount) != "/etc/flyte/secrets":
+                raise ValueError("Only /etc/flyte/secrets is supported as secret mount path today.")
         if self.as_env_var is not None:
             pattern = r"^[A-Z_][A-Z0-9_]*$"
             if not re.match(pattern, self.as_env_var):
                 raise ValueError(f"Invalid environment variable name: {self.as_env_var}, must match {pattern}")
 
+    def stable_hash(self) -> str:
+        """
+        Deterministic, process-independent hash (as hex string).
+        """
+        import hashlib
+
+        data = (
+            self.key,
+            self.group or "",
+            str(self.mount) if self.mount else "",
+            self.as_env_var or "",
+        )
+        joined = "|".join(data)
+        return hashlib.sha256(joined.encode("utf-8")).hexdigest()
+
+    def __hash__(self) -> int:
+        """
+        Deterministic hash function for the Secret class.
+        """
+        return int(self.stable_hash()[:16], 16)
+
 
 SecretRequest = Union[str, Secret, List[str | Secret]]
 
@@ -59,3 +86,12 @@ def secrets_from_request(secrets: SecretRequest) -> List[Secret]:
         return [secrets]
     else:
         return [Secret(key=s) if isinstance(s, str) else s for s in secrets]
+
+
+if __name__ == "__main__":
+    # Example usage
+    secret1 = Secret(key="MY_SECRET", mount=pathlib.Path("/path/to/secret"), as_env_var="MY_SECRET_ENV")
+    secret2 = Secret(
+        key="ANOTHER_SECRET",
+    )
+    print(hash(secret1), hash(secret2))

flyte/_serve.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import hashlib
+import pathlib
+from dataclasses import replace
+from typing import TYPE_CHECKING, Optional
+
+import cloudpickle
+
+from flyte._initialize import get_init_config
+from flyte._logging import LogFormat, logger
+from flyte._tools import ipython_check
+from flyte.models import SerializationContext
+from flyte.syncify import syncify
+
+if TYPE_CHECKING:
+    import flyte.io
+    from flyte.app import AppEnvironment
+    from flyte.remote import App
+
+    from ._code_bundle import CopyFiles
+
+
+class _Serve:
+    """
+    Context manager for serving apps with custom configuration.
+
+    Similar to _Runner for tasks, but specifically for AppEnvironment serving.
+    """
+
+    def __init__(
+        self,
+        version: Optional[str] = None,
+        copy_style: CopyFiles = "loaded_modules",
+        dry_run: bool = False,
+        project: str | None = None,
+        domain: str | None = None,
+        env_vars: dict[str, str] | None = None,
+        parameter_values: dict[str, dict[str, str | flyte.io.File | flyte.io.Dir]] | None = None,
+        cluster_pool: str | None = None,
+        log_level: int | None = None,
+        log_format: LogFormat = "console",
+        interactive_mode: bool | None = None,
+        copy_bundle_to: pathlib.Path | None = None,
+    ):
+        """
+        Initialize serve context.
+
+        Args:
+            version: Optional version override for the app deployment
+            copy_style: Code bundle copy style (default: "loaded_modules")
+            dry_run: If True, don't actually deploy (default: False)
+            project: Optional project override
+            domain: Optional domain override
+            env_vars: Optional environment variables to inject into the app
+            parameter_values: Optional parameter values to inject into the app
+            cluster_pool: Optional cluster pool override
+            log_level: Optional log level to set for the app (e.g., logging.INFO)
+            log_format: Optional log format ("console" or "json", default: "console")
+            interactive_mode: If True, raises NotImplementedError (apps don't support interactive/notebook mode)
+            copy_bundle_to: When dry_run is True, the bundle will be copied to this location if specified
+        """
+        self._version = version
+        self._copy_style = copy_style
+        self._dry_run = dry_run
+        self._project = project
+        self._domain = domain
+        self._env_vars = env_vars or {}
+        self._parameter_values = parameter_values or {}
+        self._cluster_pool = cluster_pool
+        self._log_level = log_level
+        self._log_format = log_format
+        self._interactive_mode = interactive_mode if interactive_mode is not None else ipython_check()
+        self._copy_bundle_to = copy_bundle_to
+
+    @syncify
+    async def serve(self, app_env: "AppEnvironment") -> "App":
+        """
+        Serve an app with the configured context.
+
+        Args:
+            app_env: The app environment to serve
+
+        Returns:
+            Deployed and activated App instance
+
+        Raises:
+            NotImplementedError: If interactive mode is detected
+        """
+        from copy import deepcopy
+
+        from flyte.app import _deploy
+
+        from ._code_bundle import build_code_bundle, build_pkl_bundle
+        from ._deploy import build_images, plan_deploy
+
+        cfg = get_init_config()
+        project = self._project or cfg.project
+        domain = self._domain or cfg.domain
+
+        # Configure logging env vars (similar to _run.py)
+        env = self._env_vars.copy()
+        if env.get("LOG_LEVEL") is None:
+            if self._log_level:
+                env["LOG_LEVEL"] = str(self._log_level)
+            else:
+                env["LOG_LEVEL"] = str(logger.getEffectiveLevel())
+        env["LOG_FORMAT"] = self._log_format
+
+        # Update env_vars with logging configuration
+        self._env_vars = env
+
+        # Plan deployment
+        deployments = plan_deploy(app_env)
+        assert deployments
+        app_deployment = deployments[0]
+
+        # Build images
+        image_cache = await build_images.aio(app_env)
+        assert image_cache
+
+        # Build code bundle (tgz style)
+        if self._interactive_mode:
+            code_bundle = await build_pkl_bundle(
+                app_env,
+                upload_to_controlplane=not self._dry_run,
+                copy_bundle_to=self._copy_bundle_to,
+            )
+        else:
+            code_bundle = await build_code_bundle(
+                from_dir=cfg.root_dir,
+                dryrun=self._dry_run,
+                copy_style=self._copy_style,
+                copy_bundle_to=self._copy_bundle_to,
+            )
+
+        # Compute version
+        if self._version:
+            version = self._version
+        elif app_deployment.version:
+            version = app_deployment.version
+        else:
+            h = hashlib.md5()
+            h.update(cloudpickle.dumps(app_deployment.envs))
+            h.update(code_bundle.computed_version.encode("utf-8"))
+            h.update(cloudpickle.dumps(image_cache))
+            version = h.hexdigest()
+
+        # Create serialization context
+        sc = SerializationContext(
+            project=project,
+            domain=domain,
+            org=cfg.org,
+            code_bundle=code_bundle,
+            version=version,
+            image_cache=image_cache,
+            root_dir=cfg.root_dir,
+        )
+
+        # Inject parameter overrides from the serve
+        parameter_overrides = None
+        if app_env_parameter_values := self._parameter_values.get(app_env.name):
+            parameter_overrides = []
+            for parameter in app_env.parameters:
+                value = app_env_parameter_values.get(parameter.name, parameter.value)
+                parameter_overrides.append(replace(parameter, value=value))
+
+        # Deploy app
+        deployed_app = await _deploy._deploy_app(app_env, sc, parameter_overrides=parameter_overrides)
+        assert deployed_app
+
+        logger.warning(f"Deployed App, you can check the console at {deployed_app.url}")
+        # Mutate app_idl if env_vars or cluster_pool are provided
+        # This is a temporary solution until the update/create APIs support these attributes
+        if self._env_vars or self._cluster_pool:
+            from flyteidl2.core import literals_pb2
+
+            app_idl = deepcopy(deployed_app.pb2)
+
+            # TODO This should be part of the params!
+            # Update env_vars
+            if self._env_vars:
+                if app_idl.spec.container:
+                    # Merge with existing env vars
+                    if app_idl.spec.container.env:
+                        existing_env = {kv.key: kv.value for kv in app_idl.spec.container.env}
+                    else:
+                        existing_env = {}
+                    existing_env.update(self._env_vars)
+                    app_idl.spec.container.env.extend(
+                        [literals_pb2.KeyValuePair(key=k, value=v) for k, v in existing_env.items()]
+                    )
+                elif app_idl.spec.pod:
+                    # For pod specs, we'd need to update the containers in the pod
+                    # This is more complex as it requires modifying the serialized pod_spec
+                    raise NotImplementedError(
+                        "Env var override for pod-based apps is not yet supported. "
+                        "Please use container-based apps or set env_vars in the AppEnvironment definition."
+                    )
+
+            # Update cluster_pool
+            if self._cluster_pool:
+                app_idl.spec.cluster_pool = self._cluster_pool
+
+            # Update the deployed app with mutated IDL
+            # Note: This is a workaround. Ideally, the API would support these fields directly
+            deployed_app = type(deployed_app)(pb2=app_idl)
+
+        # Watch for activation
+        return await deployed_app.watch.aio(wait_for="activated")
+
+
+def with_servecontext(
+    version: Optional[str] = None,
+    copy_style: CopyFiles = "loaded_modules",
+    dry_run: bool = False,
+    project: str | None = None,
+    domain: str | None = None,
+    env_vars: dict[str, str] | None = None,
+    parameter_values: dict[str, dict[str, str | flyte.io.File | flyte.io.Dir]] | None = None,
+    cluster_pool: str | None = None,
+    log_level: int | None = None,
+    log_format: LogFormat = "console",
+    interactive_mode: bool | None = None,
+    copy_bundle_to: pathlib.Path | None = None,
+) -> _Serve:
+    """
+    Create a serve context with custom configuration.
+
+    This function allows you to customize how an app is served, including
+    overriding environment variables, cluster pool, logging, and other deployment settings.
+
+    Example:
+    ```python
+    import logging
+    import flyte
+    from flyte.app.extras import FastAPIAppEnvironment
+
+    env = FastAPIAppEnvironment(name="my-app", ...)
+
+    # Serve with custom env vars, logging, and cluster pool
+    app = flyte.with_servecontext(
+        env_vars={"DATABASE_URL": "postgresql://..."},
+        log_level=logging.DEBUG,
+        log_format="json",
+        cluster_pool="gpu-pool",
+        project="my-project",
+        domain="development",
+    ).serve(env)
+
+    print(f"App URL: {app.url}")
+    ```
+
+    Args:
+        version: Optional version override for the app deployment
+        copy_style: Code bundle copy style. Options: "loaded_modules", "all", "none" (default: "loaded_modules")
+        dry_run: If True, don't actually deploy (default: False)
+        project: Optional project override
+        domain: Optional domain override
+        env_vars: Optional environment variables to inject/override in the app container
+        parameter_values: Optional parameter values to inject/override in the app container. Must be a dictionary that
+            maps app environment names to a dictionary of parameter names to values.
+        cluster_pool: Optional cluster pool to deploy the app to
+        log_level: Optional log level (e.g., logging.DEBUG, logging.INFO). If not provided, uses init config or default
+        log_format: Optional log format ("console" or "json", default: "console")
+        interactive_mode: Optional, can be forced to True or False.
+            If not provided, it will be set based on the current environment. For example Jupyter notebooks are
+            considered interactive mode, while scripts are not. This is used to determine how the code bundle is
+            created. This is used to determine if the app should be served in interactive mode or not.
+        copy_bundle_to: When dry_run is True, the bundle will be copied to this location if specified
+
+    Returns:
+        _Serve: Serve context manager with configured settings
+
+    Raises:
+        NotImplementedError: If called from a notebook/interactive environment
+
+    Notes:
+        - Apps do not support pickle-based bundling (interactive mode)
+        - LOG_LEVEL and LOG_FORMAT are automatically set as env vars if not explicitly provided in env_vars
+        - The env_vars and cluster_pool overrides mutate the app IDL after creation
+        - This is a temporary solution until the API natively supports these fields
+    """
+    return _Serve(
+        version=version,
+        copy_style=copy_style,
+        dry_run=dry_run,
+        project=project,
+        domain=domain,
+        env_vars=env_vars,
+        parameter_values=parameter_values,
+        cluster_pool=cluster_pool,
+        log_level=log_level,
+        log_format=log_format,
+        interactive_mode=interactive_mode,
+        copy_bundle_to=copy_bundle_to,
+    )
+
+
+@syncify
+async def serve(app_env: "AppEnvironment") -> "App":
+    """
+    Serve a Flyte app using an AppEnvironment.
+
+    This is the simple, direct way to serve an app. For more control over
+    deployment settings (env vars, cluster pool, etc.), use with_servecontext().
+
+    Example:
+    ```python
+    import flyte
+    from flyte.app.extras import FastAPIAppEnvironment
+
+    env = FastAPIAppEnvironment(name="my-app", ...)
+
+    # Simple serve
+    app = flyte.serve(env)
+    print(f"App URL: {app.url}")
+    ```
+
+    Args:
+        app_env: The app environment to serve
+
+    Returns:
+        Deployed and activated App instance
+
+    Raises:
+        NotImplementedError: If called from a notebook/interactive environment
+
+    See Also:
+        with_servecontext: For customizing deployment settings
+    """
+    # Use default serve context
+    return await _Serve().serve.aio(app_env)