flyte 0.0.1b3__py3-none-any.whl → 0.2.0a0__py3-none-any.whl

union/_internal/runtime/task_serde.py

@@ -1,202 +0,0 @@
-"""
-This module provides functionality to serialize and deserialize tasks to and from the wire format.
-It includes a Resolver interface for loading tasks, and functions to load classes and tasks.
-"""
-
-import importlib
-from typing import List, Optional, Type
-
-from flyteidl.core import identifier_pb2, literals_pb2, security_pb2, tasks_pb2
-from google.protobuf import duration_pb2, wrappers_pb2
-
-from union._cache.cache import VersionParameters, cache_from_request
-from union._datastructures import SerializationContext
-from union._internal.resolvers.common import Resolver
-from union._logging import logger
-from union._protos.workflow import task_definition_pb2
-from union._secret import SecretRequest, secrets_from_request
-from union._task import AsyncFunctionTaskTemplate, TaskTemplate
-
-from ..._timeout import timeout_from_request
-from .resources_serde import get_proto_extended_resources, get_proto_resources
-from .types_serde import transform_native_to_typed_interface
-
-
-def load_class(qualified_name) -> Type:
-    """
-    Load a class from a qualified name. The qualified name should be in the format 'module.ClassName'.
-    :param qualified_name: The qualified name of the class to load.
-    :return: The class object.
-    """
-    module_name, class_name = qualified_name.rsplit(".", 1)  # Split module and class
-    module = importlib.import_module(module_name)  # Import the module
-    return getattr(module, class_name)  # Retrieve the class
-
-
-def load_task(resolver: str, *resolver_args: str) -> TaskTemplate:
-    """
-    Load a task from a resolver. This is a placeholder function.
-
-    :param resolver: The resolver to use to load the task.
-    :param resolver_args: Arguments to pass to the resolver.
-    :return: The loaded task.
-    """
-    resolver_class = load_class(resolver)
-    resolver_instance = resolver_class()
-    return resolver_instance.load_task(resolver_args)
-
-
-def get_task_loader_args(resolver: Resolver, task: TaskTemplate) -> List[str]:
-    """
-    Get the task loader args from a resolver. This is a placeholder function.
-
-    :param resolver: The resolver to use to load the task.
-    :param task: The task to get the loader args for.
-
-    :return: The loader args for the task.
-    """
-    return resolver.loader_args(task)
-
-
-def translate_task_to_wire(
-    task: TaskTemplate, serialization_context: SerializationContext
-) -> task_definition_pb2.TaskSpec:
-    """
-    Translate a task to a wire format. This is a placeholder function.
-
-    :param task: The task to translate.
-    :param serialization_context: The serialization context to use for the translation.
-
-    :return: The translated task.
-    """
-    # Placeholder implementation
-    return get_proto_task(task, serialization_context)
-
-
-def get_security_context(secrets: Optional[SecretRequest]) -> Optional[security_pb2.SecurityContext]:
-    """
-    Get the security context from a list of secrets. This is a placeholder function.
-
-    :param secrets: The list of secrets to use for the security context.
-
-    :return: The security context.
-    """
-    if secrets is None:
-        return None
-
-    secret_list = secrets_from_request(secrets)
-    return security_pb2.SecurityContext(
-        secrets=[
-            security_pb2.Secret(
-                group=secret.group,
-                key=secret.key,
-                mount_requirement=(
-                    security_pb2.Secret.MountType.ENV_VAR if secret.as_env_var else security_pb2.Secret.MountType.FILE
-                ),
-                env_var=secret.as_env_var,
-            )
-            for secret in secret_list
-        ]
-    )
-
-
-def get_proto_task(task: TaskTemplate, serialize_context: SerializationContext) -> task_definition_pb2.TaskSpec:
-    task_id = identifier_pb2.Identifier(
-        resource_type=identifier_pb2.ResourceType.TASK,
-        project=serialize_context.project,
-        domain=serialize_context.domain,
-        org=serialize_context.org,
-        name=task.name,
-        version=serialize_context.version,
-    )
-
-    # TODO, there will be tasks that do not have images, handle that case
-    # if task.parent_env is None:
-    # raise ValueError(f"Task {task.name} must have a parent environment")
-
-    #
-    # This pod will be incorrect when doing fast serialize
-    #
-    pod = None
-    sql = None
-    container = _get_urun_container(serialize_context, task)
-    # pod = task.get_k8s_pod(serialize_context)
-    extra_config = {}
-    custom = {}
-    task_cache = cache_from_request(task.cache)
-
-    # -------------- CACHE HANDLING ----------------------
-    task_cache = cache_from_request(task.cache)
-    cache_enabled = task_cache.is_enabled()
-    cache_version = None
-
-    if task_cache.is_enabled():
-        logger.debug(f"Cache enabled for task {task.name}")
-        if serialize_context.code_bundle and serialize_context.code_bundle.pkl:
-            logger.debug(f"Detected pkl bundle for task {task.name}, using computed version as cache version")
-            cache_version = serialize_context.code_bundle.computed_version
-        else:
-            version_parameters = None
-            if isinstance(task, AsyncFunctionTaskTemplate):
-                version_parameters = VersionParameters(func=task.func, image=task.image)
-            else:
-                version_parameters = VersionParameters(func=None, image=task.image)
-            cache_version = task_cache.get_version(version_parameters)
-            logger.debug(f"Cache version for task {task.name} is {cache_version}")
-    else:
-        logger.debug(f"Cache disabled for task {task.name}")
-
-    tt = tasks_pb2.TaskTemplate(
-        id=task_id,
-        type=task.task_type,
-        metadata=tasks_pb2.TaskMetadata(
-            discoverable=cache_enabled,
-            discovery_version=cache_version,
-            cache_serializable=task_cache.serialize,
-            cache_ignore_input_vars=task.cache.ignored_inputs,
-            runtime=tasks_pb2.RuntimeMetadata(),
-            retries=literals_pb2.RetryStrategy(retries=task.retries.count),
-            timeout=duration_pb2.Duration(seconds=timeout_from_request(task.timeout).max_runtime.seconds)
-            if task.timeout
-            else None,
-            pod_template_name=task.pod_template if task.pod_template and isinstance(task.pod_template, str) else None,
-            interruptible=task.interruptable,
-            generates_deck=wrappers_pb2.BoolValue(value=False),  # TODO add support for reports
-        ),
-        interface=transform_native_to_typed_interface(task.native_interface),
-        custom=custom,
-        container=container,
-        task_type_version=task.task_type_version,
-        security_context=get_security_context(task.secrets),
-        config=extra_config,
-        k8s_pod=pod,
-        sql=sql,
-        extended_resources=get_proto_extended_resources(task.resources),
-    )
-    return task_definition_pb2.TaskSpec(task_template=tt)
-
-
-def _get_urun_container(
-    serialize_context: SerializationContext, task_template: TaskTemplate
-) -> Optional[tasks_pb2.Container]:
-    env = (
-        [literals_pb2.KeyValuePair(key=k, value=v) for k, v in task_template.env.items()] if task_template.env else None
-    )
-    resources = get_proto_resources(task_template.resources)
-    # pr: under what conditions should this return None?
-    image_id = task_template.image.identifier
-    if not serialize_context.image_cache or image_id not in serialize_context.image_cache.image_lookup:
-        # This computes the image uri, computing hashes as necessary so can fail if done remotely.
-        img_uri = task_template.image.uri
-    else:
-        img_uri = serialize_context.image_cache.image_lookup[image_id]
-
-    return tasks_pb2.Container(
-        image=img_uri,
-        command=[],
-        args=task_template.container_args(serialize_context),
-        resources=resources,
-        env=env,
-        data_config=task_template.data_loading_config(serialize_context),
-        config=task_template.config(serialize_context),
-    )

union/_internal/runtime/taskrunner.py

@@ -1,179 +0,0 @@
-"""
-This module is responsible for running tasks in the V2 runtime. All methods in this file should be
-invoked within a context tree.
-"""
-
-import logging
-import pathlib
-from typing import Any, Dict, List, Optional, Tuple
-
-from union._context import internal_ctx
-from union._datastructures import ActionID, Checkpoints, CodeBundle, RawDataPath, TaskContext
-from union._internal.imagebuild.image_builder import ImageCache
-from union._logging import log, logger
-from union._task import TaskTemplate
-from union.errors import CustomError, RuntimeSystemError, RuntimeUnknownError, RuntimeUserError
-
-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', 'union._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
-    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
-            case "--name":
-                args[i + 1] = action.name
-    return args
-
-
-@log(level=logging.INFO)
-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 | None,
-    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,
-        version=version,
-        raw_data_path=raw_data_path,
-        compiled_image_cache=image_cache,
-    )
-    async 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)
-        return await convert_from_native_to_outputs(out, task.native_interface), None
-
-
-async def extract_download_run_upload(
-    task: TaskTemplate,
-    *,
-    action: ActionID,
-    controller: Controller,
-    raw_data_path: RawDataPath,
-    output_path: str,
-    version: str,
-    checkpoints: Checkpoints | None = None,
-    code_bundle: CodeBundle | None = None,
-    input_path: str | Inputs | 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,
-        action=action,
-        controller=controller,
-        raw_data_path=raw_data_path,
-        output_path=output_path,
-        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}")

union/_internal/runtime/types_serde.py

@@ -1,53 +0,0 @@
-from typing import Dict, Optional, TypeVar
-
-from flyteidl.core import interface_pb2
-
-from union._datastructures import NativeInterface
-from union.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
-    if interface.docstring is None:
-        input_descriptions = output_descriptions = {}
-    else:
-        # 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,
-    )

union/_logging.py

@@ -1,124 +0,0 @@
-from __future__ import annotations
-
-import logging
-import os
-from typing import Optional
-
-from ._tools import ipython_check, is_in_cluster
-
-DEFAULT_LOG_LEVEL = logging.INFO
-
-
-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 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("union", 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("union", get_env_log_level())

union/_protos/common/authorization_pb2.py

@@ -1,66 +0,0 @@
-# -*- 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 union._protos.common import identifier_pb2 as common_dot_identifier__pb2
-from union._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*\xf4\x03\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\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=1561
-  _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)