flyte 0.1.0__py3-none-any.whl → 0.2.0a0__py3-none-any.whl

flyte/_internal/runtime/taskrunner.py

@@ -0,0 +1,191 @@
+"""
+This module is responsible for running tasks in the V2 runtime. All methods in this file should be
+invoked within a context tree.
+"""
+
+import pathlib
+from typing import Any, Dict, List, Optional, Tuple
+
+import flyte.report
+from flyte._context import internal_ctx
+from flyte._internal.imagebuild.image_builder import ImageCache
+from flyte._logging import log, logger
+from flyte._task import TaskTemplate
+from flyte.errors import CustomError, RuntimeSystemError, RuntimeUnknownError, RuntimeUserError
+from flyte.models import ActionID, Checkpoints, CodeBundle, RawDataPath, TaskContext
+
+from .. import Controller
+from .convert import (
+    Error,
+    Inputs,
+    Outputs,
+    convert_from_native_to_error,
+    convert_from_native_to_outputs,
+    convert_inputs_to_native,
+)
+from .io import load_inputs, upload_error, upload_outputs
+
+
+def replace_task_cli(args: List[str], inputs: Inputs, tmp_path: pathlib.Path, action: ActionID) -> List[str]:
+    """
+    This method can be used to run an task from the cli, if you have cli for the task. It will replace,
+    all the args with the task args.
+
+    The urun cli is of the format
+    ```python
+    ['urun', '--inputs', '{{.Inputs}}', '--outputs-path', '{{.Outputs}}', '--version', '',
+     '--raw-data-path', '{{.rawOutputDataPrefix}}',
+      '--checkpoint-path', '{{.checkpointOutputPrefix}}', '--prev-checkpoint', '{{.prevCheckpointPrefix}}',
+       '--run-name', '{{.runName}}', '--name', '{{.actionName}}',
+        '--tgz', 'some-path', '--dest', '.',
+         '--resolver', 'flyte._internal.resolvers.default.DefaultTaskResolver', '--resolver-args',
+          'mod', 'test_round_trip', 'instance', 'task1']
+    ```
+    We will replace, inputs, outputs, raw_data_path, checkpoint_path, prev_checkpoint, run_name, name
+    with supplied values.
+
+    :param args: urun command
+    :param inputs: converted inputs to the task
+    :param tmp_path: temporary path to use for the task
+    :param action: run id to use for the task
+    :return: modified args
+    """
+    # Iterate over all the args and replace the inputs, outputs, raw_data_path, checkpoint_path, prev_checkpoint,
+    # root_name, run_name with the supplied values
+    # first we will write the inputs to a file called inputs.pb
+    inputs_path = tmp_path / "inputs.pb"
+    with open(inputs_path, "wb") as f:
+        f.write(inputs.proto_inputs.SerializeToString())
+    # now modify the args
+    args = list(args)  # copy first because it's a proto container
+    for i, arg in enumerate(args):
+        match arg:
+            case "--inputs":
+                args[i + 1] = str(inputs_path)
+            case "--outputs-path":
+                args[i + 1] = str(tmp_path)
+            case "--raw-data-path":
+                args[i + 1] = str(tmp_path / "raw_data_path")
+            case "--checkpoint-path":
+                args[i + 1] = str(tmp_path / "checkpoint_path")
+            case "--prev-checkpoint":
+                args[i + 1] = str(tmp_path / "prev_checkpoint")
+            case "--run-name":
+                args[i + 1] = action.run_name or ""
+            case "--name":
+                args[i + 1] = action.name
+    insert_point = args.index("--raw-data-path")
+    args.insert(insert_point, str(tmp_path))
+    args.insert(insert_point, "--run-base-dir")
+    return args
+
+
+@log
+async def run_task(
+    tctx: TaskContext, controller: Controller, task: TaskTemplate, inputs: Dict[str, Any]
+) -> Tuple[Any, Optional[Exception]]:
+    try:
+        logger.info(f"Parent task executing {tctx.action}")
+        outputs = await task.execute(**inputs)
+        logger.info(f"Parent task completed successfully, {tctx.action}")
+        return outputs, None
+    except RuntimeSystemError as e:
+        logger.exception(f"Task failed with error: {e}")
+        return {}, e
+    except RuntimeUnknownError as e:
+        logger.exception(f"Task failed with error: {e}")
+        return {}, e
+    except RuntimeUserError as e:
+        logger.exception(f"Task failed with error: {e}")
+        return {}, e
+    except Exception as e:
+        logger.exception(f"Task failed with error: {e}")
+        return {}, CustomError.from_exception(e)
+    finally:
+        logger.info(f"Parent task finalized {tctx.action}")
+        # reconstruct run id here
+        await controller.finalize_parent_action(tctx.action)
+
+
+async def convert_and_run(
+    *,
+    task: TaskTemplate,
+    inputs: Inputs,
+    action: ActionID,
+    controller: Controller,
+    raw_data_path: RawDataPath,
+    version: str,
+    output_path: str,
+    run_base_dir: str,
+    checkpoints: Checkpoints | None = None,
+    code_bundle: CodeBundle | None = None,
+    image_cache: ImageCache | None = None,
+) -> Tuple[Optional[Outputs], Optional[Error]]:
+    """
+    This method is used to convert the inputs to native types, and run the task. It assumes you are running
+    in a context tree.
+    """
+    ctx = internal_ctx()
+    tctx = TaskContext(
+        action=action,
+        checkpoints=checkpoints,
+        code_bundle=code_bundle,
+        output_path=output_path,
+        run_base_dir=run_base_dir,
+        version=version,
+        raw_data_path=raw_data_path,
+        compiled_image_cache=image_cache,
+        report=flyte.report.Report(name=action.name),
+        mode="remote" if not ctx.data.task_context else ctx.data.task_context.mode,
+    )
+    with ctx.replace_task_context(tctx):
+        inputs_kwargs = await convert_inputs_to_native(inputs, task.native_interface)
+        out, err = await run_task(tctx=tctx, controller=controller, task=task, inputs=inputs_kwargs)
+        if err is not None:
+            return None, convert_from_native_to_error(err)
+        if task.report:
+            await flyte.report.flush.aio()
+        return await convert_from_native_to_outputs(out, task.native_interface, task.name), None
+
+
+async def extract_download_run_upload(
+    task: TaskTemplate,
+    *,
+    action: ActionID,
+    controller: Controller,
+    raw_data_path: RawDataPath,
+    output_path: str,
+    run_base_dir: str,
+    version: str,
+    checkpoints: Checkpoints | None = None,
+    code_bundle: CodeBundle | None = None,
+    input_path: str | None = None,
+    image_cache: ImageCache | None = None,
+):
+    """
+    This method is invoked from the CLI (urun) and is used to run a task. This assumes that the context tree
+    has already been created, and the task has been loaded. It also handles the loading of the task.
+    """
+    inputs = await load_inputs(input_path) if input_path else None
+    outputs, err = await convert_and_run(
+        task=task,
+        inputs=inputs or Inputs.empty(),
+        action=action,
+        controller=controller,
+        raw_data_path=raw_data_path,
+        output_path=output_path,
+        run_base_dir=run_base_dir,
+        version=version,
+        checkpoints=checkpoints,
+        code_bundle=code_bundle,
+        image_cache=image_cache,
+    )
+    if err is not None:
+        path = await upload_error(err.err, output_path)
+        logger.error(f"Task {task.name} failed with error: {err}. Uploaded error to {path}")
+        return
+    if outputs is None:
+        logger.info(f"Task {task.name} completed successfully, no outputs")
+        return
+    await upload_outputs(outputs, output_path) if output_path else None
+    logger.info(f"Task {task.name} completed successfully, uploaded outputs to {output_path}")

flyte/_internal/runtime/types_serde.py

@@ -0,0 +1,54 @@
+from typing import Dict, Optional, TypeVar
+
+from flyteidl.core import interface_pb2
+
+from flyte.models import NativeInterface
+from flyte.types._type_engine import TypeEngine
+
+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))
+    return res
+
+
+def transform_native_to_typed_interface(
+    interface: Optional[NativeInterface],
+) -> Optional[interface_pb2.TypedInterface]:
+    """
+    Transform the given simple python native interface to FlyteIDL's 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)
+    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:
+    # add artifact handling eventually
+    return interface_pb2.Variable(
+        type=TypeEngine.to_literal_type(x),
+        description=description,
+    )

flyte/_logging.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+from ._tools import ipython_check, is_in_cluster
+
+DEFAULT_LOG_LEVEL = logging.WARNING
+
+
+def make_hyperlink(label: str, url: str):
+    """
+    Create a hyperlink in the terminal output.
+    """
+    BLUE = "\033[94m"
+    RESET = "\033[0m"
+    OSC8_BEGIN = f"\033]8;;{url}\033\\"
+    OSC8_END = "\033]8;;\033\\"
+    return f"{BLUE}{OSC8_BEGIN}{label}{RESET}{OSC8_END}"
+
+
+def is_rich_logging_disabled() -> bool:
+    """
+    Check if rich logging is enabled
+    """
+    return os.environ.get("DISABLE_RICH_LOGGING") is not None
+
+
+def get_env_log_level() -> int:
+    return int(os.environ.get("LOG_LEVEL", DEFAULT_LOG_LEVEL))
+
+
+def log_format_from_env() -> str:
+    """
+    Get the log format from the environment variable.
+    """
+    return os.environ.get("LOG_FORMAT", "json")
+
+
+def get_rich_handler(log_level: int) -> Optional[logging.Handler]:
+    """
+    Upgrades the global loggers to use Rich logging.
+    """
+    if is_in_cluster():
+        return None
+    if not ipython_check() and is_rich_logging_disabled():
+        return None
+
+    import click
+    from rich.console import Console
+    from rich.logging import RichHandler
+
+    try:
+        width = os.get_terminal_size().columns
+    except Exception as e:
+        logger.debug(f"Failed to get terminal size: {e}")
+        width = 160
+
+    handler = RichHandler(
+        tracebacks_suppress=[click],
+        rich_tracebacks=True,
+        omit_repeated_times=False,
+        show_path=False,
+        log_time_format="%H:%M:%S.%f",
+        console=Console(width=width),
+        level=log_level,
+    )
+
+    formatter = logging.Formatter(fmt="%(filename)s:%(lineno)d - %(message)s")
+    handler.setFormatter(formatter)
+    return handler
+
+
+def get_default_handler(log_level: int) -> logging.Handler:
+    handler = logging.StreamHandler()
+    handler.setLevel(log_level)
+    formatter = logging.Formatter(fmt="[%(name)s] %(message)s")
+    if log_format_from_env() == "json":
+        pass
+        # formatter = jsonlogger.JsonFormatter(fmt="%(asctime)s %(name)s %(levelname)s %(message)s")
+    handler.setFormatter(formatter)
+    return handler
+
+
+def initialize_logger(log_level: int = DEFAULT_LOG_LEVEL, enable_rich: bool = False):
+    """
+    Initializes the global loggers to the default configuration.
+    """
+    global logger  # noqa: PLW0603
+    logger = _create_logger("flyte", log_level, enable_rich)
+
+
+def _create_logger(name: str, log_level: int = DEFAULT_LOG_LEVEL, enable_rich: bool = False) -> logging.Logger:
+    """
+    Creates a logger with the given name and log level.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(log_level)
+    handler = None
+    logger.handlers = []
+    if enable_rich:
+        handler = get_rich_handler(log_level)
+    if handler is None:
+        handler = get_default_handler(log_level)
+    logger.addHandler(handler)
+    return logger
+
+
+def log(fn=None, *, level=logging.DEBUG, entry=True, exit=True):
+    """
+    Decorator to log function calls.
+    """
+
+    def decorator(func):
+        if logger.isEnabledFor(level):
+
+            def wrapper(*args, **kwargs):
+                if entry:
+                    logger.log(level, f"[{func.__name__}] with args: {args} and kwargs: {kwargs}")
+                try:
+                    return func(*args, **kwargs)
+                finally:
+                    if exit:
+                        logger.log(level, f"[{func.__name__}] completed")
+
+            return wrapper
+        return func
+
+    if fn is None:
+        return decorator
+    return decorator(fn)
+
+
+logger = _create_logger("flyte", get_env_log_level())

flyte/_map.py

@@ -0,0 +1,215 @@
+import asyncio
+from typing import Any, AsyncGenerator, AsyncIterator, Generic, Iterable, Iterator, List, Union, cast
+
+from flyte.syncify import syncify
+
+from ._group import group
+from ._logging import logger
+from ._task import P, R, TaskTemplate
+
+
+class MapAsyncIterator(Generic[P, R]):
+    """AsyncIterator implementation for the map function results"""
+
+    def __init__(self, func: TaskTemplate[P, R], args: tuple, name: str, concurrency: int, return_exceptions: bool):
+        self.func = func
+        self.args = args
+        self.name = name
+        self.concurrency = concurrency
+        self.return_exceptions = return_exceptions
+        self._tasks: List[asyncio.Task] = []
+        self._current_index = 0
+        self._completed_count = 0
+        self._exception_count = 0
+        self._task_count = 0
+        self._initialized = False
+
+    def __aiter__(self) -> AsyncIterator[Union[R, Exception]]:
+        """Return self as the async iterator"""
+        return self
+
+    async def __anext__(self) -> Union[R, Exception]:
+        """Get the next result"""
+        # Initialize on first call
+        if not self._initialized:
+            await self._initialize()
+
+        # Check if we've exhausted all tasks
+        if self._current_index >= self._task_count:
+            raise StopAsyncIteration
+
+        # Get the next task result
+        task = self._tasks[self._current_index]
+        self._current_index += 1
+
+        try:
+            result = await task
+            self._completed_count += 1
+            logger.debug(f"Task {self._current_index - 1} completed successfully")
+            return result
+        except Exception as e:
+            self._exception_count += 1
+            logger.debug(f"Task {self._current_index - 1} failed with exception: {e}")
+            if self.return_exceptions:
+                return e
+            else:
+                # Cancel remaining tasks
+                for remaining_task in self._tasks[self._current_index + 1 :]:
+                    remaining_task.cancel()
+                raise e
+
+    async def _initialize(self):
+        """Initialize the tasks - called lazily on first iteration"""
+        # Create all tasks at once
+        tasks = []
+        task_count = 0
+
+        for arg_tuple in zip(*self.args):
+            task = asyncio.create_task(self.func.aio(*arg_tuple))
+            tasks.append(task)
+            task_count += 1
+
+        if task_count == 0:
+            logger.info(f"Group '{self.name}' has no tasks to process")
+            self._tasks = []
+            self._task_count = 0
+        else:
+            logger.info(f"Starting {task_count} tasks in group '{self.name}' with unlimited concurrency")
+            self._tasks = tasks
+            self._task_count = task_count
+
+        self._initialized = True
+
+    async def collect(self) -> List[Union[R, Exception]]:
+        """Convenience method to collect all results into a list"""
+        results = []
+        async for result in self:
+            results.append(result)
+        return results
+
+    def __repr__(self):
+        return f"MapAsyncIterator(group_name='{self.name}', concurrency={self.concurrency})"
+
+
+class _Mapper(Generic[P, R]):
+    """
+    Internal mapper class to handle the mapping logic
+
+    NOTE: The reason why we do not use the `@syncify` decorator here is because, in `syncify` we cannot use
+    context managers like `group` directly in the function body. This is because the `__exit__` method of the
+    context manager is called after the function returns. An for `_context` the `__exit__` method releases the
+    token (for contextvar), which was created in a separate thread. This leads to an exception like:
+
+    """
+
+    @classmethod
+    def _get_name(cls, task_name: str, group_name: str | None) -> str:
+        """Get the name of the group, defaulting to 'map' if not provided."""
+        return f"{task_name}_{group_name or 'map'}"
+
+    def __call__(
+        self,
+        func: TaskTemplate[P, R],
+        *args: Iterable[Any],
+        group_name: str | None = None,
+        concurrency: int = 0,
+        return_exceptions: bool = True,
+    ) -> Iterator[Union[R, Exception]]:
+        """
+        Map a function over the provided arguments with concurrent execution.
+
+        :param func: The async function to map.
+        :param args: Positional arguments to pass to the function (iterables that will be zipped).
+        :param group_name: The name of the group for the mapped tasks.
+        :param concurrency: The maximum number of concurrent tasks to run. If 0, run all tasks concurrently.
+        :param return_exceptions: If True, yield exceptions instead of raising them.
+        :return: AsyncIterator yielding results in order.
+        """
+        if not args:
+            return
+
+        name = self._get_name(func.name, group_name)
+        logger.debug(f"Blocking Map for {name}")
+        with group(name):
+            import flyte
+
+            tctx = flyte.ctx()
+            if tctx is None or tctx.mode == "local":
+                logger.warning("Running map in local mode, which will run every task sequentially.")
+                for v in zip(*args):
+                    try:
+                        yield func(*v)  # type: ignore
+                    except Exception as e:
+                        if return_exceptions:
+                            yield e
+                        else:
+                            raise e
+                return
+
+            i = 0
+            for x in cast(
+                Iterator[R],
+                _map(
+                    func,
+                    *args,
+                    name=name,
+                    concurrency=concurrency,
+                    return_exceptions=True,
+                ),
+            ):
+                logger.debug(f"Mapped {x}, task {i}")
+                i += 1
+                yield x
+
+    async def aio(
+        self,
+        func: TaskTemplate[P, R],
+        *args: Iterable[Any],
+        group_name: str | None = None,
+        concurrency: int = 0,
+        return_exceptions: bool = True,
+    ) -> AsyncGenerator[Union[R, Exception], None]:
+        if not args:
+            return
+        name = self._get_name(func.name, group_name)
+        with group(name):
+            import flyte
+
+            tctx = flyte.ctx()
+            if tctx is None or tctx.mode == "local":
+                logger.warning("Running map in local mode, which will run every task sequentially.")
+                for v in zip(*args):
+                    try:
+                        yield func(*v)  # type: ignore
+                    except Exception as e:
+                        if return_exceptions:
+                            yield e
+                        else:
+                            raise e
+                return
+            async for x in _map.aio(
+                func,
+                *args,
+                name=name,
+                concurrency=concurrency,
+                return_exceptions=return_exceptions,
+            ):
+                yield cast(Union[R, Exception], x)
+
+
+@syncify
+async def _map(
+    func: TaskTemplate[P, R],
+    *args: Iterable[Any],
+    name: str = "map",
+    concurrency: int = 0,
+    return_exceptions: bool = True,
+) -> AsyncIterator[Union[R, Exception]]:
+    iter = MapAsyncIterator(
+        func=func, args=args, name=name, concurrency=concurrency, return_exceptions=return_exceptions
+    )
+    async for result in iter:
+        yield result
+
+
+map: _Mapper = _Mapper()

flyte/_pod.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Dict, Optional
+
+if TYPE_CHECKING:
+    from kubernetes.client import V1PodSpec
+
+
+_PRIMARY_CONTAINER_NAME_FIELD = "primary_container_name"
+_PRIMARY_CONTAINER_DEFAULT_NAME = "primary"
+
+
+@dataclass(init=True, repr=True, eq=True, frozen=False)
+class PodTemplate(object):
+    """Custom PodTemplate specification for a Task."""
+
+    pod_spec: Optional["V1PodSpec"] = field(default_factory=lambda: V1PodSpec())
+    primary_container_name: str = _PRIMARY_CONTAINER_DEFAULT_NAME
+    labels: Optional[Dict[str, str]] = None
+    annotations: Optional[Dict[str, str]] = None

flyte/_protos/common/authorization_pb2.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: common/authorization.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from flyte._protos.common import identifier_pb2 as common_dot_identifier__pb2
+from flyte._protos.validate.validate import validate_pb2 as validate_dot_validate__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1a\x63ommon/authorization.proto\x12\x0f\x63loudidl.common\x1a\x17\x63ommon/identifier.proto\x1a\x17validate/validate.proto\"+\n\x0cOrganization\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xfa\x42\x04r\x02\x10\x01R\x04name\"i\n\x06\x44omain\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12K\n\x0corganization\x18\x02 \x01(\x0b\x32\x1d.cloudidl.common.OrganizationB\x08\xfa\x42\x05\x8a\x01\x02\x10\x01R\x0corganization\"a\n\x07Project\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xfa\x42\x04r\x02\x10\x01R\x04name\x12\x39\n\x06\x64omain\x18\x02 \x01(\x0b\x32\x17.cloudidl.common.DomainB\x08\xfa\x42\x05\x8a\x01\x02\x10\x01R\x06\x64omain\"e\n\x08Workflow\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xfa\x42\x04r\x02\x10\x01R\x04name\x12<\n\x07project\x18\x02 \x01(\x0b\x32\x18.cloudidl.common.ProjectB\x08\xfa\x42\x05\x8a\x01\x02\x10\x01R\x07project\"g\n\nLaunchPlan\x12\x1b\n\x04name\x18\x01 \x01(\tB\x07\xfa\x42\x04r\x02\x10\x01R\x04name\x12<\n\x07project\x18\x02 \x01(\x0b\x32\x18.cloudidl.common.ProjectB\x08\xfa\x42\x05\x8a\x01\x02\x10\x01R\x07project\"\xfd\x02\n\x08Resource\x12\x43\n\x0corganization\x18\x01 \x01(\x0b\x32\x1d.cloudidl.common.OrganizationH\x00R\x0corganization\x12\x31\n\x06\x64omain\x18\x02 \x01(\x0b\x32\x17.cloudidl.common.DomainH\x00R\x06\x64omain\x12\x34\n\x07project\x18\x03 \x01(\x0b\x32\x18.cloudidl.common.ProjectH\x00R\x07project\x12\x37\n\x08workflow\x18\x04 \x01(\x0b\x32\x19.cloudidl.common.WorkflowH\x00R\x08workflow\x12>\n\x0blaunch_plan\x18\x05 \x01(\x0b\x32\x1b.cloudidl.common.LaunchPlanH\x00R\nlaunchPlan\x12>\n\x07\x63luster\x18\x06 \x01(\x0b\x32\".cloudidl.common.ClusterIdentifierH\x00R\x07\x63lusterB\n\n\x08resource\"v\n\nPermission\x12\x35\n\x08resource\x18\x01 \x01(\x0b\x32\x19.cloudidl.common.ResourceR\x08resource\x12\x31\n\x07\x61\x63tions\x18\x02 \x03(\x0e\x32\x17.cloudidl.common.ActionR\x07\x61\x63tions*\x94\x04\n\x06\x41\x63tion\x12\x0f\n\x0b\x41\x43TION_NONE\x10\x00\x12\x15\n\rACTION_CREATE\x10\x01\x1a\x02\x08\x01\x12\x13\n\x0b\x41\x43TION_READ\x10\x02\x1a\x02\x08\x01\x12\x15\n\rACTION_UPDATE\x10\x03\x1a\x02\x08\x01\x12\x15\n\rACTION_DELETE\x10\x04\x1a\x02\x08\x01\x12\x1f\n\x1b\x41\x43TION_VIEW_FLYTE_INVENTORY\x10\x05\x12 \n\x1c\x41\x43TION_VIEW_FLYTE_EXECUTIONS\x10\x06\x12#\n\x1f\x41\x43TION_REGISTER_FLYTE_INVENTORY\x10\x07\x12\"\n\x1e\x41\x43TION_CREATE_FLYTE_EXECUTIONS\x10\x08\x12\x1d\n\x19\x41\x43TION_ADMINISTER_PROJECT\x10\t\x12\x1d\n\x19\x41\x43TION_MANAGE_PERMISSIONS\x10\n\x12\x1d\n\x19\x41\x43TION_ADMINISTER_ACCOUNT\x10\x0b\x12\x19\n\x15\x41\x43TION_MANAGE_CLUSTER\x10\x0c\x12,\n(ACTION_EDIT_EXECUTION_RELATED_ATTRIBUTES\x10\r\x12*\n&ACTION_EDIT_CLUSTER_RELATED_ATTRIBUTES\x10\x0e\x12!\n\x1d\x41\x43TION_EDIT_UNUSED_ATTRIBUTES\x10\x0f\x12\x1e\n\x1a\x41\x43TION_SUPPORT_SYSTEM_LOGS\x10\x10\x42\xb3\x01\n\x13\x63om.cloudidl.commonB\x12\x41uthorizationProtoH\x02P\x01Z)github.com/unionai/cloud/gen/pb-go/common\xa2\x02\x03\x43\x43X\xaa\x02\x0f\x43loudidl.Common\xca\x02\x0f\x43loudidl\\Common\xe2\x02\x1b\x43loudidl\\Common\\GPBMetadata\xea\x02\x10\x43loudidl::Commonb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'common.authorization_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\023com.cloudidl.commonB\022AuthorizationProtoH\002P\001Z)github.com/unionai/cloud/gen/pb-go/common\242\002\003CCX\252\002\017Cloudidl.Common\312\002\017Cloudidl\\Common\342\002\033Cloudidl\\Common\\GPBMetadata\352\002\020Cloudidl::Common'
+  _ACTION.values_by_name["ACTION_CREATE"]._options = None
+  _ACTION.values_by_name["ACTION_CREATE"]._serialized_options = b'\010\001'
+  _ACTION.values_by_name["ACTION_READ"]._options = None
+  _ACTION.values_by_name["ACTION_READ"]._serialized_options = b'\010\001'
+  _ACTION.values_by_name["ACTION_UPDATE"]._options = None
+  _ACTION.values_by_name["ACTION_UPDATE"]._serialized_options = b'\010\001'
+  _ACTION.values_by_name["ACTION_DELETE"]._options = None
+  _ACTION.values_by_name["ACTION_DELETE"]._serialized_options = b'\010\001'
+  _ORGANIZATION.fields_by_name['name']._options = None
+  _ORGANIZATION.fields_by_name['name']._serialized_options = b'\372B\004r\002\020\001'
+  _DOMAIN.fields_by_name['organization']._options = None
+  _DOMAIN.fields_by_name['organization']._serialized_options = b'\372B\005\212\001\002\020\001'
+  _PROJECT.fields_by_name['name']._options = None
+  _PROJECT.fields_by_name['name']._serialized_options = b'\372B\004r\002\020\001'
+  _PROJECT.fields_by_name['domain']._options = None
+  _PROJECT.fields_by_name['domain']._serialized_options = b'\372B\005\212\001\002\020\001'
+  _WORKFLOW.fields_by_name['name']._options = None
+  _WORKFLOW.fields_by_name['name']._serialized_options = b'\372B\004r\002\020\001'
+  _WORKFLOW.fields_by_name['project']._options = None
+  _WORKFLOW.fields_by_name['project']._serialized_options = b'\372B\005\212\001\002\020\001'
+  _LAUNCHPLAN.fields_by_name['name']._options = None
+  _LAUNCHPLAN.fields_by_name['name']._serialized_options = b'\372B\004r\002\020\001'
+  _LAUNCHPLAN.fields_by_name['project']._options = None
+  _LAUNCHPLAN.fields_by_name['project']._serialized_options = b'\372B\005\212\001\002\020\001'
+  _globals['_ACTION']._serialized_start=1061
+  _globals['_ACTION']._serialized_end=1593
+  _globals['_ORGANIZATION']._serialized_start=97
+  _globals['_ORGANIZATION']._serialized_end=140
+  _globals['_DOMAIN']._serialized_start=142
+  _globals['_DOMAIN']._serialized_end=247
+  _globals['_PROJECT']._serialized_start=249
+  _globals['_PROJECT']._serialized_end=346
+  _globals['_WORKFLOW']._serialized_start=348
+  _globals['_WORKFLOW']._serialized_end=449
+  _globals['_LAUNCHPLAN']._serialized_start=451
+  _globals['_LAUNCHPLAN']._serialized_end=554
+  _globals['_RESOURCE']._serialized_start=557
+  _globals['_RESOURCE']._serialized_end=938
+  _globals['_PERMISSION']._serialized_start=940
+  _globals['_PERMISSION']._serialized_end=1058
+# @@protoc_insertion_point(module_scope)