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

flyte/_internal/runtime/trigger_serde.py

@@ -0,0 +1,162 @@
+import asyncio
+from typing import Union
+
+from flyteidl2.core import interface_pb2, literals_pb2
+from flyteidl2.task import common_pb2, run_pb2, task_definition_pb2
+from google.protobuf import timestamp_pb2, wrappers_pb2
+
+import flyte.types
+from flyte import Cron, FixedRate, Trigger, TriggerTime
+
+
+def _to_schedule(m: Union[Cron, FixedRate], kickoff_arg_name: str | None = None) -> common_pb2.Schedule:
+    if isinstance(m, Cron):
+        return common_pb2.Schedule(
+            cron=common_pb2.Cron(
+                expression=m.expression,
+                timezone=m.timezone,
+            ),
+            kickoff_time_input_arg=kickoff_arg_name,
+        )
+    elif isinstance(m, FixedRate):
+        start_time = None
+        if m.start_time is not None:
+            start_time = timestamp_pb2.Timestamp()
+            start_time.FromDatetime(m.start_time)
+
+        return common_pb2.Schedule(
+            rate=common_pb2.FixedRate(
+                value=m.interval_minutes,
+                unit=common_pb2.FixedRateUnit.FIXED_RATE_UNIT_MINUTE,
+                start_time=start_time,
+            ),
+            kickoff_time_input_arg=kickoff_arg_name,
+        )
+
+
+async def process_default_inputs(
+    default_inputs: dict,
+    task_name: str,
+    task_inputs: interface_pb2.VariableMap,
+    task_default_inputs: list[common_pb2.NamedParameter],
+) -> list[common_pb2.NamedLiteral]:
+    """
+    Process default inputs and convert them to NamedLiteral objects.
+
+    Args:
+        default_inputs: Dictionary of default input values
+        task_name: Name of the task for error messages
+        task_inputs: Task input variable map
+        task_default_inputs: List of default parameters from task
+
+    Returns:
+        List of NamedLiteral objects
+    """
+    keys = []
+    literal_coros = []
+    for k, v in default_inputs.items():
+        if k not in task_inputs.variables:
+            raise ValueError(
+                f"Trigger default input '{k}' must be an input to the task, but not found in task {task_name}. "
+                f"Available inputs: {list(task_inputs.variables.keys())}"
+            )
+        else:
+            literal_coros.append(flyte.types.TypeEngine.to_literal(v, type(v), task_inputs.variables[k].type))
+            keys.append(k)
+
+    final_literals: list[literals_pb2.Literal] = await asyncio.gather(*literal_coros, return_exceptions=True)
+
+    # Check for exceptions in the gathered results
+    for k, lit in zip(keys, final_literals):
+        if isinstance(lit, Exception):
+            raise RuntimeError(f"Failed to convert trigger default input '{k}'") from lit
+
+    for p in task_default_inputs or []:
+        if p.name not in keys:
+            keys.append(p.name)
+            final_literals.append(p.parameter.default)
+
+    literals: list[common_pb2.NamedLiteral] = []
+    for k, lit in zip(keys, final_literals):
+        literals.append(
+            common_pb2.NamedLiteral(
+                name=k,
+                value=lit,
+            )
+        )
+
+    return literals
+
+
+async def to_task_trigger(
+    t: Trigger,
+    task_name: str,
+    task_inputs: interface_pb2.VariableMap,
+    task_default_inputs: list[common_pb2.NamedParameter],
+) -> task_definition_pb2.TaskTrigger:
+    """
+    Converts a Trigger object to a TaskTrigger protobuf object.
+    Args:
+        t:
+        task_name:
+        task_inputs:
+        task_default_inputs:
+    Returns:
+
+    """
+    env = None
+    if t.env_vars:
+        env = run_pb2.Envs()
+        for k, v in t.env_vars.items():
+            env.values.append(literals_pb2.KeyValuePair(key=k, value=v))
+
+    labels = run_pb2.Labels(values=t.labels) if t.labels else None
+
+    annotations = run_pb2.Annotations(values=t.annotations) if t.annotations else None
+
+    run_spec = run_pb2.RunSpec(
+        overwrite_cache=t.overwrite_cache,
+        envs=env,
+        interruptible=wrappers_pb2.BoolValue(value=t.interruptible) if t.interruptible is not None else None,
+        cluster=t.queue,
+        labels=labels,
+        annotations=annotations,
+    )
+
+    kickoff_arg_name = None
+    default_inputs = {}
+    if t.inputs:
+        for k, v in t.inputs.items():
+            if v is TriggerTime:
+                kickoff_arg_name = k
+            else:
+                default_inputs[k] = v
+
+    # assert that default_inputs and the kickoff_arg_name are infact in the task inputs
+    if kickoff_arg_name is not None and kickoff_arg_name not in task_inputs.variables:
+        raise ValueError(
+            f"For a scheduled trigger, the TriggerTime input '{kickoff_arg_name}' "
+            f"must be an input to the task, but not found in task {task_name}. "
+            f"Available inputs: {list(task_inputs.variables.keys())}"
+        )
+
+    literals = await process_default_inputs(default_inputs, task_name, task_inputs, task_default_inputs)
+
+    automation = _to_schedule(
+        t.automation,
+        kickoff_arg_name=kickoff_arg_name,
+    )
+
+    return task_definition_pb2.TaskTrigger(
+        name=t.name,
+        spec=task_definition_pb2.TaskTriggerSpec(
+            active=t.auto_activate,
+            run_spec=run_spec,
+            inputs=common_pb2.Inputs(literals=literals),
+            description=t.description,
+        ),
+        automation_spec=common_pb2.TriggerAutomationSpec(
+            type=common_pb2.TriggerAutomationSpecType.TYPE_SCHEDULE,
+            schedule=automation,
+        ),
+    )

flyte/_internal/runtime/types_serde.py

@@ -1,8 +1,8 @@
 from typing import Dict, Optional, TypeVar
 
-from flyteidl.core import interface_pb2
+from flyteidl2.core import interface_pb2
 
-from flyte._datastructures import NativeInterface
+from flyte.models import NativeInterface
 from flyte.types._type_engine import TypeEngine
 
 T = TypeVar("T")
@@ -10,17 +10,15 @@ T = TypeVar("T")
 
 def transform_variable_map(
     variable_map: Dict[str, type],
-    descriptions: Optional[Dict[str, str]] = None,
 ) -> Dict[str, interface_pb2.Variable]:
     """
     Given a map of str (names of inputs for instance) to their Python native types, return a map of the name to a
     Flyte Variable object with that type.
     """
     res = {}
-    descriptions = descriptions or {}
     if variable_map:
         for k, v in variable_map.items():
-            res[k] = transform_type(v, descriptions.get(k, k))
+            res[k] = transform_type(v)
     return res
 
 
@@ -32,23 +30,16 @@ def transform_native_to_typed_interface(
     """
     if interface is None:
         return None
-    input_descriptions: Dict[str, str] = {}
-    output_descriptions: Dict[str, str] = {}
-    if interface.docstring:
-        # Fill in descriptions from docstring in the future
-        input_descriptions = {}
-        output_descriptions = {}
-
-    inputs_map = transform_variable_map(interface.get_input_types(), input_descriptions)
-    outputs_map = transform_variable_map(interface.outputs, output_descriptions)
+
+    inputs_map = transform_variable_map(interface.get_input_types())
+    outputs_map = transform_variable_map(interface.outputs)
     return interface_pb2.TypedInterface(
         inputs=interface_pb2.VariableMap(variables=inputs_map), outputs=interface_pb2.VariableMap(variables=outputs_map)
     )
 
 
-def transform_type(x: type, description: Optional[str] = None) -> interface_pb2.Variable:
+def transform_type(x: type) -> interface_pb2.Variable:
     # add artifact handling eventually
     return interface_pb2.Variable(
         type=TypeEngine.to_literal_type(x),
-        description=description,
     )

flyte/_keyring/file.py

@@ -0,0 +1,115 @@
+from base64 import decodebytes, encodebytes
+from configparser import ConfigParser, NoOptionError, NoSectionError
+from pathlib import Path
+from typing import Optional
+
+from keyring.backend import KeyringBackend
+from keyring.errors import PasswordDeleteError
+
+_FLYTE_KEYRING_PATH: Path = Path.home() / ".flyte" / "keyring.cfg"
+
+
+class SimplePlainTextKeyring(KeyringBackend):
+    """
+    Simple plain text keyring for remote notebook environments.
+
+    This backend is only active when running in IPython/Jupyter notebooks.
+    For local development, the system keyring is used instead.
+    """
+
+    @property
+    def priority(self):
+        """
+        Return priority based on whether we're in a notebook environment.
+        Negative priority means this backend will be skipped by keyring.
+        """
+        from flyte._tools import ipython_check
+
+        if ipython_check():
+            # In IPython/Jupyter - use this backend
+            return 0.5
+        else:
+            # Not in IPython - skip this backend, let system keyring handle it
+            return -1
+
+    def get_password(self, service: str, username: str) -> Optional[str]:
+        """Get password."""
+        if not self.file_path.exists():
+            return None
+
+        config = ConfigParser(interpolation=None)
+        config.read(self.file_path, encoding="utf-8")
+
+        try:
+            password_base64 = config.get(service, username).encode("utf-8")
+            return decodebytes(password_base64).decode("utf-8")
+        except (NoOptionError, NoSectionError):
+            return None
+
+    def delete_password(self, service: str, username: str) -> None:
+        """Delete password."""
+        if not self.file_path.exists():
+            raise PasswordDeleteError("Config file does not exist")
+
+        config = ConfigParser(interpolation=None)
+        config.read(self.file_path, encoding="utf-8")
+
+        try:
+            if not config.remove_option(service, username):
+                raise PasswordDeleteError("Password not found")
+        except NoSectionError:
+            raise PasswordDeleteError("Password not found")
+
+        with self.file_path.open("w", encoding="utf-8") as config_file:
+            config.write(config_file)
+
+    def set_password(self, service: str, username: str, password: str) -> None:
+        """Set password."""
+        if not username:
+            raise ValueError("Username must be provided")
+
+        file_path = self._ensure_file_path()
+        value = encodebytes(password.encode("utf-8")).decode("utf-8")
+
+        config = ConfigParser(interpolation=None)
+        config.read(file_path, encoding="utf-8")
+
+        if not config.has_section(service):
+            config.add_section(service)
+
+        config.set(service, username, value)
+
+        with file_path.open("w", encoding="utf-8") as config_file:
+            config.write(config_file)
+
+    def _ensure_file_path(self):
+        self.file_path.parent.mkdir(exist_ok=True, parents=True)
+        if not self.file_path.is_file():
+            self.file_path.touch(0o600)
+        return self.file_path
+
+    @property
+    def file_path(self) -> Path:
+        from flyte._initialize import get_init_config, is_initialized
+        from flyte._logging import logger
+
+        # Only try to use source_config_path if flyte.init() has been called
+        if is_initialized():
+            try:
+                config = get_init_config()
+                config_path = config.source_config_path
+                if config_path and str(config_path.parent.name) == ".flyte":
+                    # if the config is in a .flyte directory, use that as the path
+                    return config_path.parent / "keyring.cfg"
+            except Exception as e:
+                # If anything fails, fall back to default path
+                logger.debug(f"Skipping config-based keyring path due to error: {e}")
+        else:
+            # flyte.init() hasn't been called, use default path
+            logger.debug("flyte.init() not called, using default keyring path")
+
+        # Default path
+        return _FLYTE_KEYRING_PATH
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}> at {self.file_path}>"

flyte/_link.py

@@ -0,0 +1,30 @@
+from typing import Dict, Optional, Protocol
+
+
+class Link(Protocol):
+    name: str
+    icon_uri: Optional[str] = ""
+
+    def get_link(
+        self,
+        run_name: str,
+        project: str,
+        domain: str,
+        context: Dict[str, str],
+        parent_action_name: str,
+        action_name: str,
+        pod_name: str,
+    ) -> str:
+        """
+        Returns a task log link given the action.
+        Link can have template variables that are replaced by the backend.
+        :param run_name: The name of the run.
+        :param project: The project name.
+        :param domain: The domain name.
+        :param context: Additional context for generating the link.
+        :param parent_action_name: The name of the parent action.
+        :param action_name: The name of the action.
+        :param pod_name: The name of the pod.
+        :return: The generated link.
+        """
+        raise NotImplementedError