openmetadata-ingestion 1.9.11.2__py3-none-any.whl → 1.10.0.0__py3-none-any.whl

metadata/sdk/entities/dashboard_services.py

@@ -0,0 +1,18 @@
+"""DashboardServices entity SDK."""
+from __future__ import annotations
+
+from typing import Type
+
+from metadata.generated.schema.api.services.createDashboardService import (
+    CreateDashboardServiceRequest,
+)
+from metadata.generated.schema.entity.services.dashboardService import DashboardService
+from metadata.sdk.entities.base import BaseEntity
+
+
+class DashboardServices(BaseEntity[DashboardService, CreateDashboardServiceRequest]):
+    """Fluent facade for dashboard service operations."""
+
+    @classmethod
+    def entity_type(cls) -> Type[DashboardService]:
+        return DashboardService

metadata/sdk/entities/dashboarddatamodels.py

@@ -0,0 +1,21 @@
+"""
+DashboardDataModels entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createDashboardDataModel import (
+    CreateDashboardDataModelRequest,
+)
+from metadata.generated.schema.entity.data.dashboardDataModel import DashboardDataModel
+from metadata.sdk.entities.base import BaseEntity
+
+
+class DashboardDataModels(
+    BaseEntity[DashboardDataModel, CreateDashboardDataModelRequest]
+):
+    """DashboardDataModels SDK class - plural to avoid conflict with generated DashboardDataModel entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[DashboardDataModel]:
+        """Return the DashboardDataModel entity type"""
+        return DashboardDataModel

metadata/sdk/entities/dashboards.py

@@ -0,0 +1,17 @@
+"""
+Dashboards entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createDashboard import CreateDashboardRequest
+from metadata.generated.schema.entity.data.dashboard import Dashboard
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Dashboards(BaseEntity[Dashboard, CreateDashboardRequest]):
+    """Dashboards SDK class - plural to avoid conflict with generated Dashboard entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Dashboard]:
+        """Return the Dashboard entity type"""
+        return Dashboard

metadata/sdk/entities/database_services.py

@@ -0,0 +1,18 @@
+"""DatabaseServices entity SDK."""
+from __future__ import annotations
+
+from typing import Type
+
+from metadata.generated.schema.api.services.createDatabaseService import (
+    CreateDatabaseServiceRequest,
+)
+from metadata.generated.schema.entity.services.databaseService import DatabaseService
+from metadata.sdk.entities.base import BaseEntity
+
+
+class DatabaseServices(BaseEntity[DatabaseService, CreateDatabaseServiceRequest]):
+    """Fluent facade for database service operations."""
+
+    @classmethod
+    def entity_type(cls) -> Type[DatabaseService]:
+        return DatabaseService

metadata/sdk/entities/databases.py

@@ -0,0 +1,17 @@
+"""
+Databases entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createDatabase import CreateDatabaseRequest
+from metadata.generated.schema.entity.data.database import Database
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Databases(BaseEntity[Database, CreateDatabaseRequest]):
+    """Databases SDK class - plural to avoid conflict with generated Database entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Database]:
+        """Return the Database entity type"""
+        return Database

metadata/sdk/entities/databaseschemas.py

@@ -0,0 +1,19 @@
+"""
+DatabaseSchemas entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createDatabaseSchema import (
+    CreateDatabaseSchemaRequest,
+)
+from metadata.generated.schema.entity.data.databaseSchema import DatabaseSchema
+from metadata.sdk.entities.base import BaseEntity
+
+
+class DatabaseSchemas(BaseEntity[DatabaseSchema, CreateDatabaseSchemaRequest]):
+    """DatabaseSchemas SDK class - plural to avoid conflict with generated DatabaseSchema entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[DatabaseSchema]:
+        """Return the DatabaseSchema entity type"""
+        return DatabaseSchema

metadata/sdk/entities/datacontracts.py

@@ -0,0 +1,19 @@
+"""
+DataContracts entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createDataContract import (
+    CreateDataContractRequest,
+)
+from metadata.generated.schema.entity.data.dataContract import DataContract
+from metadata.sdk.entities.base import BaseEntity
+
+
+class DataContracts(BaseEntity[DataContract, CreateDataContractRequest]):
+    """DataContracts SDK class - plural to avoid conflict with generated DataContract entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[DataContract]:
+        """Return the DataContract entity type"""
+        return DataContract

metadata/sdk/entities/dataproducts.py

@@ -0,0 +1,19 @@
+"""
+DataProducts entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.domains.createDataProduct import (
+    CreateDataProductRequest,
+)
+from metadata.generated.schema.entity.domains.dataProduct import DataProduct
+from metadata.sdk.entities.base import BaseEntity
+
+
+class DataProducts(BaseEntity[DataProduct, CreateDataProductRequest]):
+    """DataProducts SDK class - plural to avoid conflict with generated DataProduct entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[DataProduct]:
+        """Return the DataProduct entity type"""
+        return DataProduct

metadata/sdk/entities/domains.py

@@ -0,0 +1,17 @@
+"""
+Domains entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.domains.createDomain import CreateDomainRequest
+from metadata.generated.schema.entity.domains.domain import Domain
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Domains(BaseEntity[Domain, CreateDomainRequest]):
+    """Domains SDK class - plural to avoid conflict with generated Domain entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Domain]:
+        """Return the Domain entity type"""
+        return Domain

metadata/sdk/entities/glossaries.py

@@ -0,0 +1,17 @@
+"""
+Glossaries entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createGlossary import CreateGlossaryRequest
+from metadata.generated.schema.entity.data.glossary import Glossary
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Glossaries(BaseEntity[Glossary, CreateGlossaryRequest]):
+    """Glossaries SDK class - plural to avoid conflict with generated Glossary entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Glossary]:
+        """Return the Glossary entity type"""
+        return Glossary

metadata/sdk/entities/glossary_terms.py

@@ -0,0 +1,18 @@
+"""Glossary terms entity SDK."""
+from __future__ import annotations
+
+from typing import Type
+
+from metadata.generated.schema.api.data.createGlossaryTerm import (
+    CreateGlossaryTermRequest,
+)
+from metadata.generated.schema.entity.data.glossaryTerm import GlossaryTerm
+from metadata.sdk.entities.base import BaseEntity
+
+
+class GlossaryTerms(BaseEntity[GlossaryTerm, CreateGlossaryTermRequest]):
+    """SDK facade for glossary term entities."""
+
+    @classmethod
+    def entity_type(cls) -> Type[GlossaryTerm]:
+        return GlossaryTerm

metadata/sdk/entities/glossaryterms.py

@@ -0,0 +1,19 @@
+"""
+GlossaryTerms entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createGlossaryTerm import (
+    CreateGlossaryTermRequest,
+)
+from metadata.generated.schema.entity.data.glossaryTerm import GlossaryTerm
+from metadata.sdk.entities.base import BaseEntity
+
+
+class GlossaryTerms(BaseEntity[GlossaryTerm, CreateGlossaryTermRequest]):
+    """GlossaryTerms SDK class - plural to avoid conflict with generated GlossaryTerm entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[GlossaryTerm]:
+        """Return the GlossaryTerm entity type"""
+        return GlossaryTerm

metadata/sdk/entities/metrics.py

@@ -0,0 +1,49 @@
+"""Metrics entity SDK."""
+from __future__ import annotations
+
+from typing import Any, Sequence, Type, cast
+
+from metadata.generated.schema.api.data.createMetric import CreateMetricRequest
+from metadata.generated.schema.entity.data.metric import Metric
+from metadata.sdk.entities.base import BaseEntity
+from metadata.sdk.types import UuidLike
+
+
+class Metrics(BaseEntity[Metric, CreateMetricRequest]):
+    """SDK facade for metric entities."""
+
+    @classmethod
+    def entity_type(cls) -> Type[Metric]:
+        return Metric
+
+    @classmethod
+    def add_related_metrics(
+        cls, metric_id: UuidLike, related_metric_ids: Sequence[UuidLike]
+    ) -> Metric:
+        """Attach related metrics to the provided metric identifier."""
+
+        if not related_metric_ids:
+            return cls.retrieve(metric_id, fields=["relatedMetrics"])
+
+        client = cls._get_client()
+        current = client.get_by_id(
+            entity=Metric,
+            entity_id=cls._stringify_identifier(metric_id),
+            fields=["relatedMetrics"],
+        )
+
+        working = getattr(current, "model_copy", None)
+        working = working(deep=True) if callable(working) else current
+
+        existing = list(getattr(working, "relatedMetrics", []) or [])
+        for related_id in related_metric_ids:
+            payload = {"id": cls._stringify_identifier(related_id)}
+            existing.append(payload)
+        setattr(working, "relatedMetrics", existing)
+
+        updated = cast(Any, client).patch(
+            entity=Metric,
+            source=current,
+            destination=working,
+        )
+        return cls._coerce_entity(updated)

metadata/sdk/entities/mlmodels.py

@@ -0,0 +1,17 @@
+"""
+MLModels entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createMlModel import CreateMlModelRequest
+from metadata.generated.schema.entity.data.mlmodel import MlModel
+from metadata.sdk.entities.base import BaseEntity
+
+
+class MLModels(BaseEntity[MlModel, CreateMlModelRequest]):
+    """MLModels SDK class - plural to avoid conflict with generated MlModel entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[MlModel]:
+        """Return the MlModel entity type"""
+        return MlModel

metadata/sdk/entities/pipelines.py

@@ -0,0 +1,17 @@
+"""
+Pipelines entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createPipeline import CreatePipelineRequest
+from metadata.generated.schema.entity.data.pipeline import Pipeline
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Pipelines(BaseEntity[Pipeline, CreatePipelineRequest]):
+    """Pipelines SDK class - plural to avoid conflict with generated Pipeline entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Pipeline]:
+        """Return the Pipeline entity type"""
+        return Pipeline

metadata/sdk/entities/queries.py

@@ -0,0 +1,17 @@
+"""
+Queries entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createQuery import CreateQueryRequest
+from metadata.generated.schema.entity.data.query import Query
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Queries(BaseEntity[Query, CreateQueryRequest]):
+    """Queries SDK class - plural to avoid conflict with generated Query entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Query]:
+        """Return the Query entity type"""
+        return Query

metadata/sdk/entities/searchindexes.py

@@ -0,0 +1,19 @@
+"""
+SearchIndexes entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createSearchIndex import (
+    CreateSearchIndexRequest,
+)
+from metadata.generated.schema.entity.data.searchIndex import SearchIndex
+from metadata.sdk.entities.base import BaseEntity
+
+
+class SearchIndexes(BaseEntity[SearchIndex, CreateSearchIndexRequest]):
+    """SearchIndexes SDK class - plural to avoid conflict with generated SearchIndex entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[SearchIndex]:
+        """Return the SearchIndex entity type"""
+        return SearchIndex

metadata/sdk/entities/storedprocedures.py

@@ -0,0 +1,19 @@
+"""
+StoredProcedures entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.data.createStoredProcedure import (
+    CreateStoredProcedureRequest,
+)
+from metadata.generated.schema.entity.data.storedProcedure import StoredProcedure
+from metadata.sdk.entities.base import BaseEntity
+
+
+class StoredProcedures(BaseEntity[StoredProcedure, CreateStoredProcedureRequest]):
+    """StoredProcedures SDK class - plural to avoid conflict with generated StoredProcedure entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[StoredProcedure]:
+        """Return the StoredProcedure entity type"""
+        return StoredProcedure

metadata/sdk/entities/tables.py

@@ -0,0 +1,68 @@
+"""Tables entity SDK with fluent helpers."""
+from __future__ import annotations
+
+from typing import Any, Type, cast
+
+from metadata.generated.schema.api.data.createTable import CreateTableRequest
+from metadata.generated.schema.entity.data.table import Table
+from metadata.sdk.entities.base import BaseEntity
+from metadata.sdk.types import UuidLike
+
+
+class Tables(BaseEntity[Table, CreateTableRequest]):
+    """SDK facade for `Table` entities."""
+
+    @classmethod
+    def entity_type(cls) -> Type[Table]:
+        return Table
+
+    @classmethod
+    def add_tag(cls, table_id: UuidLike, tag_fqn: str) -> Table:
+        """Attach a classification or glossary tag to the table."""
+        client = cls._get_client()
+        current = client.get_by_id(
+            entity=Table,
+            entity_id=cls._stringify_identifier(table_id),
+            fields=["tags"],
+        )
+
+        working = getattr(current, "model_copy", None)
+        working = working(deep=True) if callable(working) else current
+
+        tags = list(getattr(working, "tags", []) or [])
+        tags.append({"tagFQN": tag_fqn})
+        setattr(working, "tags", tags)
+
+        updated = cast(Any, client).patch(
+            entity=Table,
+            source=current,
+            destination=working,
+        )
+        return cls._coerce_entity(updated)
+
+    @classmethod
+    def update_column_description(
+        cls, table_id: UuidLike, column_name: str, description: str
+    ) -> Table:
+        """Update the description for a specific column."""
+        client = cls._get_client()
+        current = client.get_by_id(
+            entity=Table,
+            entity_id=cls._stringify_identifier(table_id),
+            fields=["columns"],
+        )
+
+        working = getattr(current, "model_copy", None)
+        working = working(deep=True) if callable(working) else current
+
+        for column in getattr(working, "columns", []) or []:
+            if getattr(column, "name", None) == column_name:
+                setattr(column, "description", description)
+                break
+
+        updated = cast(Any, client).patch(
+            entity=Table,
+            source=current,
+            destination=working,
+        )
+        return cls._coerce_entity(updated)

metadata/sdk/entities/tags.py

@@ -0,0 +1,17 @@
+"""
+Tags entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.classification.createTag import CreateTagRequest
+from metadata.generated.schema.entity.classification.tag import Tag
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Tags(BaseEntity[Tag, CreateTagRequest]):
+    """Tags SDK class - plural to avoid conflict with generated Tag entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Tag]:
+        """Return the Tag entity type"""
+        return Tag

metadata/sdk/entities/teams.py

@@ -0,0 +1,17 @@
+"""
+Teams entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.teams.createTeam import CreateTeamRequest
+from metadata.generated.schema.entity.teams.team import Team
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Teams(BaseEntity[Team, CreateTeamRequest]):
+    """Teams SDK class - plural to avoid conflict with generated Team entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[Team]:
+        """Return the Team entity type"""
+        return Team

metadata/sdk/entities/testcases.py

@@ -0,0 +1,17 @@
+"""
+TestCases entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.tests.createTestCase import CreateTestCaseRequest
+from metadata.generated.schema.tests.testCase import TestCase
+from metadata.sdk.entities.base import BaseEntity
+
+
+class TestCases(BaseEntity[TestCase, CreateTestCaseRequest]):
+    """TestCases SDK class - plural to avoid conflict with generated TestCase entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[TestCase]:
+        """Return the TestCase entity type"""
+        return TestCase

metadata/sdk/entities/testdefinitions.py

@@ -0,0 +1,19 @@
+"""
+TestDefinitions entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.tests.createTestDefinition import (
+    CreateTestDefinitionRequest,
+)
+from metadata.generated.schema.tests.testDefinition import TestDefinition
+from metadata.sdk.entities.base import BaseEntity
+
+
+class TestDefinitions(BaseEntity[TestDefinition, CreateTestDefinitionRequest]):
+    """TestDefinitions SDK class - plural to avoid conflict with generated TestDefinition entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[TestDefinition]:
+        """Return the TestDefinition entity type"""
+        return TestDefinition

metadata/sdk/entities/testsuites.py

@@ -0,0 +1,17 @@
+"""
+TestSuites entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.tests.createTestSuite import CreateTestSuiteRequest
+from metadata.generated.schema.tests.testSuite import TestSuite
+from metadata.sdk.entities.base import BaseEntity
+
+
+class TestSuites(BaseEntity[TestSuite, CreateTestSuiteRequest]):
+    """TestSuites SDK class - plural to avoid conflict with generated TestSuite entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[TestSuite]:
+        """Return the TestSuite entity type"""
+        return TestSuite

metadata/sdk/entities/users.py

@@ -0,0 +1,17 @@
+"""
+Users entity SDK with fluent API
+"""
+from typing import Type
+
+from metadata.generated.schema.api.teams.createUser import CreateUserRequest
+from metadata.generated.schema.entity.teams.user import User
+from metadata.sdk.entities.base import BaseEntity
+
+
+class Users(BaseEntity[User, CreateUserRequest]):
+    """Users SDK class - plural to avoid conflict with generated User entity"""
+
+    @classmethod
+    def entity_type(cls) -> Type[User]:
+        """Return the User entity type"""
+        return User