hydra-ext 0.17.4__py3-none-any.whl

hydra/atlas.py

@@ -0,0 +1,469 @@
+# Note: this is an automatically generated file. Do not edit.
+
+r"""The Apache Atlas meta-model
+Based on the the org.apache.atlas.model package in the master branch as of 2022-06-01
+  https://github.com/apache/atlas/tree/master/intg/src/main/java/org/apache/atlas/model."""
+
+from __future__ import annotations
+from collections.abc import Mapping, Sequence, Set
+from dataclasses import dataclass, replace
+from enum import Enum
+from functools import lru_cache
+from hydra.overlay.python.dsl.python import Optional
+from hydra.overlay.python.util import ConsList, Lazy, PersistentMap, PersistentSet
+from typing import Annotated, TypeAlias, cast
+import hydra.core
+import hydra.xml.schema
+
+@dataclass(frozen=True)
+class AtlasAttributeDef:
+    r"""class that captures details of a struct-attribute."""
+
+    name: Optional[str]
+    type_name: Optional[str]
+    is_optional: bool
+    cardinality: Optional[AtlasAttributeDefCardinality]
+    values_min_count: int
+    values_max_count: int
+    is_unique: bool
+    is_indexable: bool
+    include_in_notification: bool
+    default_value: Optional[str]
+    description: Optional[str]
+    search_weight: int
+    index_type: Optional[AtlasAttributeDefIndexType]
+    constraints: Sequence[AtlasConstraintDef]
+    options: Mapping[str, str]
+    display_name: Optional[str]
+
+    TYPE_ = hydra.core.Name("hydra.atlas.AtlasAttributeDef")
+    NAME = hydra.core.Name("name")
+    TYPE_NAME = hydra.core.Name("typeName")
+    IS_OPTIONAL = hydra.core.Name("isOptional")
+    CARDINALITY = hydra.core.Name("cardinality")
+    VALUES_MIN_COUNT = hydra.core.Name("valuesMinCount")
+    VALUES_MAX_COUNT = hydra.core.Name("valuesMaxCount")
+    IS_UNIQUE = hydra.core.Name("isUnique")
+    IS_INDEXABLE = hydra.core.Name("isIndexable")
+    INCLUDE_IN_NOTIFICATION = hydra.core.Name("includeInNotification")
+    DEFAULT_VALUE = hydra.core.Name("defaultValue")
+    DESCRIPTION = hydra.core.Name("description")
+    SEARCH_WEIGHT = hydra.core.Name("searchWeight")
+    INDEX_TYPE = hydra.core.Name("indexType")
+    CONSTRAINTS = hydra.core.Name("constraints")
+    OPTIONS = hydra.core.Name("options")
+    DISPLAY_NAME = hydra.core.Name("displayName")
+
+    def with_name(self, name):
+        return replace(self, name=name)
+    def with_type_name(self, type_name):
+        return replace(self, type_name=type_name)
+    def with_is_optional(self, is_optional):
+        return replace(self, is_optional=is_optional)
+    def with_cardinality(self, cardinality):
+        return replace(self, cardinality=cardinality)
+    def with_values_min_count(self, values_min_count):
+        return replace(self, values_min_count=values_min_count)
+    def with_values_max_count(self, values_max_count):
+        return replace(self, values_max_count=values_max_count)
+    def with_is_unique(self, is_unique):
+        return replace(self, is_unique=is_unique)
+    def with_is_indexable(self, is_indexable):
+        return replace(self, is_indexable=is_indexable)
+    def with_include_in_notification(self, include_in_notification):
+        return replace(self, include_in_notification=include_in_notification)
+    def with_default_value(self, default_value):
+        return replace(self, default_value=default_value)
+    def with_description(self, description):
+        return replace(self, description=description)
+    def with_search_weight(self, search_weight):
+        return replace(self, search_weight=search_weight)
+    def with_index_type(self, index_type):
+        return replace(self, index_type=index_type)
+    def with_constraints(self, constraints):
+        return replace(self, constraints=constraints)
+    def with_options(self, options):
+        return replace(self, options=options)
+    def with_display_name(self, display_name):
+        return replace(self, display_name=display_name)
+
+    @staticmethod
+    def builder():
+        return AtlasAttributeDef.Builder()
+    @dataclass(frozen=True)
+    class Builder:
+        _name: Optional[str] = None
+        _type_name: Optional[str] = None
+        _is_optional: bool = None
+        _cardinality: Optional[AtlasAttributeDefCardinality] = None
+        _values_min_count: int = None
+        _values_max_count: int = None
+        _is_unique: bool = None
+        _is_indexable: bool = None
+        _include_in_notification: bool = None
+        _default_value: Optional[str] = None
+        _description: Optional[str] = None
+        _search_weight: int = None
+        _index_type: Optional[AtlasAttributeDefIndexType] = None
+        _constraints: Sequence[AtlasConstraintDef] = None
+        _options: Mapping[str, str] = None
+        _display_name: Optional[str] = None
+        def name(self, name):
+            return replace(self, _name=name)
+        def type_name(self, type_name):
+            return replace(self, _type_name=type_name)
+        def is_optional(self, is_optional):
+            return replace(self, _is_optional=is_optional)
+        def cardinality(self, cardinality):
+            return replace(self, _cardinality=cardinality)
+        def values_min_count(self, values_min_count):
+            return replace(self, _values_min_count=values_min_count)
+        def values_max_count(self, values_max_count):
+            return replace(self, _values_max_count=values_max_count)
+        def is_unique(self, is_unique):
+            return replace(self, _is_unique=is_unique)
+        def is_indexable(self, is_indexable):
+            return replace(self, _is_indexable=is_indexable)
+        def include_in_notification(self, include_in_notification):
+            return replace(self, _include_in_notification=include_in_notification)
+        def default_value(self, default_value):
+            return replace(self, _default_value=default_value)
+        def description(self, description):
+            return replace(self, _description=description)
+        def search_weight(self, search_weight):
+            return replace(self, _search_weight=search_weight)
+        def index_type(self, index_type):
+            return replace(self, _index_type=index_type)
+        def constraints(self, constraints):
+            return replace(self, _constraints=constraints)
+        def options(self, options):
+            return replace(self, _options=options)
+        def display_name(self, display_name):
+            return replace(self, _display_name=display_name)
+        def build(self):
+            return AtlasAttributeDef(name=self._name,
+            type_name=self._type_name,
+            is_optional=self._is_optional,
+            cardinality=self._cardinality,
+            values_min_count=self._values_min_count,
+            values_max_count=self._values_max_count,
+            is_unique=self._is_unique,
+            is_indexable=self._is_indexable,
+            include_in_notification=self._include_in_notification,
+            default_value=self._default_value,
+            description=self._description,
+            search_weight=self._search_weight,
+            index_type=self._index_type,
+            constraints=self._constraints,
+            options=self._options,
+            display_name=self._display_name)
+
+class AtlasAttributeDefCardinality(Enum):
+    r"""The cardinality of an Atlas attribute: single-valued, a list, or a set."""
+
+    SINGLE = hydra.core.Name("single")
+
+    LIST = hydra.core.Name("list")
+
+    SET = hydra.core.Name("set")
+
+AtlasAttributeDefCardinality.TYPE_ = hydra.core.Name("hydra.atlas.AtlasAttributeDefCardinality")
+
+class AtlasAttributeDefIndexType(Enum):
+    r"""The index type of an Atlas attribute."""
+
+    DEFAULT = hydra.core.Name("default")
+
+    STRING = hydra.core.Name("string")
+
+AtlasAttributeDefIndexType.TYPE_ = hydra.core.Name("hydra.atlas.AtlasAttributeDefIndexType")
+
+@dataclass(frozen=True)
+class AtlasBaseTypeDef:
+    r"""Base class that captures common-attributes for all Atlas types."""
+
+    category: Optional[TypeCategory]
+    guid: Optional[str]
+    created_by: Optional[str]
+    updated_by: Optional[str]
+    create_time: Optional[hydra.xml.schema.DateTime]
+    update_time: Optional[hydra.xml.schema.DateTime]
+    version: Optional[int]
+    name: Optional[str]
+    description: Optional[str]
+    type_version: Optional[str]
+    service_type: Optional[str]
+    options: Mapping[str, str]
+
+    TYPE_ = hydra.core.Name("hydra.atlas.AtlasBaseTypeDef")
+    CATEGORY = hydra.core.Name("category")
+    GUID = hydra.core.Name("guid")
+    CREATED_BY = hydra.core.Name("createdBy")
+    UPDATED_BY = hydra.core.Name("updatedBy")
+    CREATE_TIME = hydra.core.Name("createTime")
+    UPDATE_TIME = hydra.core.Name("updateTime")
+    VERSION = hydra.core.Name("version")
+    NAME = hydra.core.Name("name")
+    DESCRIPTION = hydra.core.Name("description")
+    TYPE_VERSION = hydra.core.Name("typeVersion")
+    SERVICE_TYPE = hydra.core.Name("serviceType")
+    OPTIONS = hydra.core.Name("options")
+
+    def with_category(self, category):
+        return replace(self, category=category)
+    def with_guid(self, guid):
+        return replace(self, guid=guid)
+    def with_created_by(self, created_by):
+        return replace(self, created_by=created_by)
+    def with_updated_by(self, updated_by):
+        return replace(self, updated_by=updated_by)
+    def with_create_time(self, create_time):
+        return replace(self, create_time=create_time)
+    def with_update_time(self, update_time):
+        return replace(self, update_time=update_time)
+    def with_version(self, version):
+        return replace(self, version=version)
+    def with_name(self, name):
+        return replace(self, name=name)
+    def with_description(self, description):
+        return replace(self, description=description)
+    def with_type_version(self, type_version):
+        return replace(self, type_version=type_version)
+    def with_service_type(self, service_type):
+        return replace(self, service_type=service_type)
+    def with_options(self, options):
+        return replace(self, options=options)
+
+    @staticmethod
+    def builder():
+        return AtlasBaseTypeDef.Builder()
+    @dataclass(frozen=True)
+    class Builder:
+        _category: Optional[TypeCategory] = None
+        _guid: Optional[str] = None
+        _created_by: Optional[str] = None
+        _updated_by: Optional[str] = None
+        _create_time: Optional[hydra.xml.schema.DateTime] = None
+        _update_time: Optional[hydra.xml.schema.DateTime] = None
+        _version: Optional[int] = None
+        _name: Optional[str] = None
+        _description: Optional[str] = None
+        _type_version: Optional[str] = None
+        _service_type: Optional[str] = None
+        _options: Mapping[str, str] = None
+        def category(self, category):
+            return replace(self, _category=category)
+        def guid(self, guid):
+            return replace(self, _guid=guid)
+        def created_by(self, created_by):
+            return replace(self, _created_by=created_by)
+        def updated_by(self, updated_by):
+            return replace(self, _updated_by=updated_by)
+        def create_time(self, create_time):
+            return replace(self, _create_time=create_time)
+        def update_time(self, update_time):
+            return replace(self, _update_time=update_time)
+        def version(self, version):
+            return replace(self, _version=version)
+        def name(self, name):
+            return replace(self, _name=name)
+        def description(self, description):
+            return replace(self, _description=description)
+        def type_version(self, type_version):
+            return replace(self, _type_version=type_version)
+        def service_type(self, service_type):
+            return replace(self, _service_type=service_type)
+        def options(self, options):
+            return replace(self, _options=options)
+        def build(self):
+            return AtlasBaseTypeDef(category=self._category,
+            guid=self._guid,
+            created_by=self._created_by,
+            updated_by=self._updated_by,
+            create_time=self._create_time,
+            update_time=self._update_time,
+            version=self._version,
+            name=self._name,
+            description=self._description,
+            type_version=self._type_version,
+            service_type=self._service_type,
+            options=self._options)
+
+@dataclass(frozen=True)
+class AtlasConstraintDef:
+    r"""class that captures details of a constraint."""
+
+    type: Optional[str]
+    params: Mapping[str, str]
+
+    TYPE_ = hydra.core.Name("hydra.atlas.AtlasConstraintDef")
+    TYPE = hydra.core.Name("type")
+    PARAMS = hydra.core.Name("params")
+
+    def with_type(self, type):
+        return replace(self, type=type)
+    def with_params(self, params):
+        return replace(self, params=params)
+
+    @staticmethod
+    def builder():
+        return AtlasConstraintDef.Builder()
+    @dataclass(frozen=True)
+    class Builder:
+        _type: Optional[str] = None
+        _params: Mapping[str, str] = None
+        def type(self, type):
+            return replace(self, _type=type)
+        def params(self, params):
+            return replace(self, _params=params)
+        def build(self):
+            return AtlasConstraintDef(type=self._type, params=self._params)
+
+@dataclass(frozen=True)
+class AtlasEntityDef:
+    r"""class that captures details of a entity-type."""
+
+    as_atlas_struct: AtlasStructDef
+    super_types: Set[str]
+    sub_types: Annotated[Set[str], "the value of this field is derived from 'superTypes' specified in all AtlasEntityDef"]
+    relationship_attribute_defs: Annotated[Sequence[AtlasRelationshipAttributeDef], "the value of this field is derived from all the relationshipDefs this entityType is referenced in"]
+    business_attribute_defs: Annotated[Mapping[str, Sequence[AtlasAttributeDef]], "the value of this field is derived from all the businessMetadataDefs this entityType is referenced in"]
+
+    TYPE_ = hydra.core.Name("hydra.atlas.AtlasEntityDef")
+    AS_ATLAS_STRUCT = hydra.core.Name("asAtlasStruct")
+    SUPER_TYPES = hydra.core.Name("superTypes")
+    SUB_TYPES = hydra.core.Name("subTypes")
+    RELATIONSHIP_ATTRIBUTE_DEFS = hydra.core.Name("relationshipAttributeDefs")
+    BUSINESS_ATTRIBUTE_DEFS = hydra.core.Name("businessAttributeDefs")
+
+    def with_as_atlas_struct(self, as_atlas_struct):
+        return replace(self, as_atlas_struct=as_atlas_struct)
+    def with_super_types(self, super_types):
+        return replace(self, super_types=super_types)
+    def with_sub_types(self, sub_types):
+        return replace(self, sub_types=sub_types)
+    def with_relationship_attribute_defs(self, relationship_attribute_defs):
+        return replace(self, relationship_attribute_defs=relationship_attribute_defs)
+    def with_business_attribute_defs(self, business_attribute_defs):
+        return replace(self, business_attribute_defs=business_attribute_defs)
+
+    @staticmethod
+    def builder():
+        return AtlasEntityDef.Builder()
+    @dataclass(frozen=True)
+    class Builder:
+        _as_atlas_struct: AtlasStructDef = None
+        _super_types: Set[str] = None
+        _sub_types: Set[str] = None
+        _relationship_attribute_defs: Sequence[AtlasRelationshipAttributeDef] = None
+        _business_attribute_defs: Mapping[str, Sequence[AtlasAttributeDef]] = None
+        def as_atlas_struct(self, as_atlas_struct):
+            return replace(self, _as_atlas_struct=as_atlas_struct)
+        def super_types(self, super_types):
+            return replace(self, _super_types=super_types)
+        def sub_types(self, sub_types):
+            return replace(self, _sub_types=sub_types)
+        def relationship_attribute_defs(self, relationship_attribute_defs):
+            return replace(self, _relationship_attribute_defs=relationship_attribute_defs)
+        def business_attribute_defs(self, business_attribute_defs):
+            return replace(self, _business_attribute_defs=business_attribute_defs)
+        def build(self):
+            return AtlasEntityDef(as_atlas_struct=self._as_atlas_struct,
+            super_types=self._super_types,
+            sub_types=self._sub_types,
+            relationship_attribute_defs=self._relationship_attribute_defs,
+            business_attribute_defs=self._business_attribute_defs)
+
+@dataclass(frozen=True)
+class AtlasRelationshipAttributeDef:
+    r"""class that captures details of a struct-attribute."""
+
+    as_atlas_attribute: AtlasAttributeDef
+    relationship_type_name: Optional[str]
+    is_legacy_attribute: bool
+
+    TYPE_ = hydra.core.Name("hydra.atlas.AtlasRelationshipAttributeDef")
+    AS_ATLAS_ATTRIBUTE = hydra.core.Name("asAtlasAttribute")
+    RELATIONSHIP_TYPE_NAME = hydra.core.Name("relationshipTypeName")
+    IS_LEGACY_ATTRIBUTE = hydra.core.Name("isLegacyAttribute")
+
+    def with_as_atlas_attribute(self, as_atlas_attribute):
+        return replace(self, as_atlas_attribute=as_atlas_attribute)
+    def with_relationship_type_name(self, relationship_type_name):
+        return replace(self, relationship_type_name=relationship_type_name)
+    def with_is_legacy_attribute(self, is_legacy_attribute):
+        return replace(self, is_legacy_attribute=is_legacy_attribute)
+
+    @staticmethod
+    def builder():
+        return AtlasRelationshipAttributeDef.Builder()
+    @dataclass(frozen=True)
+    class Builder:
+        _as_atlas_attribute: AtlasAttributeDef = None
+        _relationship_type_name: Optional[str] = None
+        _is_legacy_attribute: bool = None
+        def as_atlas_attribute(self, as_atlas_attribute):
+            return replace(self, _as_atlas_attribute=as_atlas_attribute)
+        def relationship_type_name(self, relationship_type_name):
+            return replace(self, _relationship_type_name=relationship_type_name)
+        def is_legacy_attribute(self, is_legacy_attribute):
+            return replace(self, _is_legacy_attribute=is_legacy_attribute)
+        def build(self):
+            return AtlasRelationshipAttributeDef(as_atlas_attribute=self._as_atlas_attribute,
+            relationship_type_name=self._relationship_type_name,
+            is_legacy_attribute=self._is_legacy_attribute)
+
+@dataclass(frozen=True)
+class AtlasStructDef:
+    r"""class that captures details of a struct-type."""
+
+    as_atlas_base_type: AtlasBaseTypeDef
+    attribute_defs: Sequence[AtlasAttributeDef]
+
+    TYPE_ = hydra.core.Name("hydra.atlas.AtlasStructDef")
+    AS_ATLAS_BASE_TYPE = hydra.core.Name("asAtlasBaseType")
+    ATTRIBUTE_DEFS = hydra.core.Name("attributeDefs")
+
+    def with_as_atlas_base_type(self, as_atlas_base_type):
+        return replace(self, as_atlas_base_type=as_atlas_base_type)
+    def with_attribute_defs(self, attribute_defs):
+        return replace(self, attribute_defs=attribute_defs)
+
+    @staticmethod
+    def builder():
+        return AtlasStructDef.Builder()
+    @dataclass(frozen=True)
+    class Builder:
+        _as_atlas_base_type: AtlasBaseTypeDef = None
+        _attribute_defs: Sequence[AtlasAttributeDef] = None
+        def as_atlas_base_type(self, as_atlas_base_type):
+            return replace(self, _as_atlas_base_type=as_atlas_base_type)
+        def attribute_defs(self, attribute_defs):
+            return replace(self, _attribute_defs=attribute_defs)
+        def build(self):
+            return AtlasStructDef(as_atlas_base_type=self._as_atlas_base_type, attribute_defs=self._attribute_defs)
+
+class TypeCategory(Enum):
+    r"""The category of an Atlas type definition."""
+
+    PRIMITIVE = hydra.core.Name("primitive")
+
+    OBJECT_ID_TYPE = hydra.core.Name("objectIdType")
+
+    ENUM = hydra.core.Name("enum")
+
+    STRUCT = hydra.core.Name("struct")
+
+    CLASSIFICATION = hydra.core.Name("classification")
+
+    ENTITY = hydra.core.Name("entity")
+
+    ARRAY = hydra.core.Name("array")
+
+    MAP = hydra.core.Name("map")
+
+    RELATIONSHIP = hydra.core.Name("relationship")
+
+    BUSINESS_METADATA = hydra.core.Name("businessMetadata")
+
+TypeCategory.TYPE_ = hydra.core.Name("hydra.atlas.TypeCategory")