NAS-4254 manage dependent entities graph

Author: hkad98

gooddata-sdk/gooddata_sdk/__init__.py

@@ -50,6 +50,7 @@
 )
 from gooddata_sdk.catalog.user.entity_model.user import CatalogUser
 from gooddata_sdk.catalog.user.entity_model.user_group import CatalogUserGroup
+from gooddata_sdk.catalog.workspace.content_service import CatalogWorkspaceContent, CatalogWorkspaceContentService
 from gooddata_sdk.catalog.workspace.declarative_model.workspace.analytics_model.analytics_model import (
     CatalogDeclarativeAnalytics,
 )
@@ -66,8 +67,11 @@
     CatalogLabel,
 )
 from gooddata_sdk.catalog.workspace.entity_model.content_objects.metric import CatalogMetric
+from gooddata_sdk.catalog.workspace.entity_model.graph_objects.graph import (
+    CatalogDependentEntitiesRequest,
+    CatalogEntityIdentifier,
+)
 from gooddata_sdk.catalog.workspace.entity_model.workspace import CatalogWorkspace
-from gooddata_sdk.catalog.workspace.service import CatalogWorkspaceContent, CatalogWorkspaceContentService
 from gooddata_sdk.client import GoodDataApiClient
 from gooddata_sdk.compute.model.attribute import Attribute
 from gooddata_sdk.compute.model.base import ExecModelEntity, ObjId

gooddata-sdk/gooddata_sdk/catalog/base.py

@@ -1,9 +1,10 @@
 # (C) 2022 GoodData Corporation
 from __future__ import annotations
 
-from typing import Any, Dict, Type, TypeVar
+from typing import Any, Dict, Optional, Type, TypeVar
 
 import attr
+import cattr
 from cattrs import structure
 
 T = TypeVar("T", bound="Base")
@@ -21,12 +22,18 @@ def value_in_allowed(instance: Type[Base], attribute: attr.Attribute, value: str
 
 @attr.s
 class Base:
+    _converter: Optional[cattr.GenConverter] = None
+
     @classmethod
     def from_api(cls: Type[T], entity: Dict[str, Any]) -> T:
         """
         Creates object from entity passed by client class, which represents it as dictionary.
         """
-        return structure(entity, cls)
+        converter = cls._custom_converter()
+        if converter is not None:
+            return converter.structure(entity, cls)
+        else:
+            return structure(entity, cls)
 
     @classmethod
     def from_dict(cls: Type[T], data: Dict[str, Any], camel_case: bool = True) -> T:
@@ -65,3 +72,7 @@ def client_class() -> Any:
     def to_api(self) -> Any:
         dictionary = self._get_snake_dict()
         return self.client_class().from_dict(dictionary, camel_case=False)
+
+    @classmethod
+    def _custom_converter(cls) -> Optional[cattr.GenConverter]:
+        return cls._converter

gooddata-sdk/gooddata_sdk/catalog/catalog_service_base.py

@@ -16,6 +16,7 @@ def __init__(self, api_client: GoodDataApiClient) -> None:
         self._client = api_client
         self._entities_api = metadata_apis.EntitiesApi(api_client.metadata_client)
         self._layout_api = metadata_apis.LayoutApi(api_client.metadata_client)
+        self._metadata_actions_api = metadata_apis.ActionsApi(api_client.metadata_client)
 
     def get_organization(self) -> CatalogOrganization:
         # The generated client does work properly with redirecting APIs

gooddata-sdk/gooddata_sdk/catalog/workspace/entity_model/graph_objects/__init__.py

@@ -0,0 +1 @@
+# (C) 2022 GoodData Corporation

gooddata-sdk/gooddata_sdk/catalog/workspace/entity_model/graph_objects/graph.py

@@ -0,0 +1,109 @@
+# (C) 2022 GoodData Corporation
+from __future__ import annotations
+
+from typing import Any, List, Optional, Type
+
+import attr
+import cattr
+from cattrs.gen import make_dict_structure_fn, make_dict_unstructure_fn, override
+
+from gooddata_metadata_client.model.dependent_entities_edge import DependentEntitiesEdge
+from gooddata_metadata_client.model.dependent_entities_graph import DependentEntitiesGraph
+from gooddata_metadata_client.model.dependent_entities_node import DependentEntitiesNode
+from gooddata_metadata_client.model.dependent_entities_request import DependentEntitiesRequest
+from gooddata_metadata_client.model.dependent_entities_response import DependentEntitiesResponse
+from gooddata_metadata_client.model.entity_identifier import EntityIdentifier
+from gooddata_sdk.catalog.base import Base
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class GraphBase(Base):
+    @classmethod
+    def _custom_converter(cls) -> Optional[cattr.GenConverter]:
+        if cls._converter is None:
+            cls._converter = cattr.GenConverter()
+            unstructured_hook = make_dict_unstructure_fn(
+                CatalogDependentEntitiesEdge, cls._converter, from_=override(rename="_from")
+            )
+            structured_hook = make_dict_structure_fn(
+                CatalogDependentEntitiesEdge, cls._converter, from_=override(rename="_from")
+            )
+            cls._converter.register_unstructure_hook(CatalogDependentEntitiesEdge, unstructured_hook)
+            cls._converter.register_structure_hook(CatalogDependentEntitiesEdge, structured_hook)
+        return cls._converter
+
+    def to_api(self) -> Any:
+        """
+        to_api method is not supported for dependent entities graph for these reasons:
+        * there is no endpoint which would require dependent entities as the input
+        * it would take some effort to change to_api to support
+        conversion regarding the from attribute (from\\_ -> _from)
+        """
+        return NotImplemented
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDependentEntitiesRequest(Base):
+    identifiers: List[CatalogEntityIdentifier] = attr.field(factory=list)
+
+    @staticmethod
+    def client_class() -> Type[DependentEntitiesRequest]:
+        return DependentEntitiesRequest
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDependentEntitiesResponse(GraphBase):
+    graph: CatalogDependentEntitiesGraph
+
+    @staticmethod
+    def client_class() -> Type[DependentEntitiesResponse]:
+        return DependentEntitiesResponse
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDependentEntitiesGraph(GraphBase):
+    nodes: List[CatalogDependentEntitiesNode] = attr.field(factory=list)
+    edges: List[CatalogDependentEntitiesEdge] = attr.field(factory=list)
+
+    @staticmethod
+    def client_class() -> Type[DependentEntitiesGraph]:
+        return DependentEntitiesGraph
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDependentEntitiesNode(Base):
+    id: str
+    type: str
+    title: Optional[str] = None
+
+    @staticmethod
+    def client_class() -> Type[DependentEntitiesNode]:
+        return DependentEntitiesNode
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogDependentEntitiesEdge(GraphBase):
+    from_: CatalogEntityIdentifier
+    """
+    Beware of the attribute from\\_ which may result in several issues.
+    Important points:
+    * from is a Python keyword and cannot be used as a variable name therefore we use from\\_ in dataclass
+    * client class uses _from naming and as a result to_dict contains _from key
+    * variable _from results in error
+    * using from_dict we expect from\\_
+    """
+    to: CatalogEntityIdentifier
+
+    @staticmethod
+    def client_class() -> Type[DependentEntitiesEdge]:
+        return DependentEntitiesEdge
+
+
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogEntityIdentifier(Base):
+    id: str
+    type: str
+
+    @staticmethod
+    def client_class() -> Type[EntityIdentifier]:
+        return EntityIdentifier

gooddata-sdk/gooddata_sdk/sdk.py

@@ -7,7 +7,8 @@
 from gooddata_sdk.catalog.organization.service import CatalogOrganizationService
 from gooddata_sdk.catalog.permission.service import CatalogPermissionService
 from gooddata_sdk.catalog.user.service import CatalogUserService
-from gooddata_sdk.catalog.workspace.service import CatalogWorkspaceContentService, CatalogWorkspaceService
+from gooddata_sdk.catalog.workspace.content_service import CatalogWorkspaceContentService
+from gooddata_sdk.catalog.workspace.service import CatalogWorkspaceService
 from gooddata_sdk.client import GoodDataApiClient
 from gooddata_sdk.compute.service import ComputeService
 from gooddata_sdk.insight import InsightService