NAS-3782 reimplemented declarative classes with attrs and cattrs

* classes uses attrs and cattrs which should make development easier in the future
* alias @attr.s was used because IntelliJ supports hinting for that when it supports new aliases such as define, the new aliases will be used
* unfortunately annotations (list, dict,...) from __future__ cannot be used, because they are not supported by combination of cattrs and python3.7 and python3.8

Author: hkad98

gooddata-sdk/gooddata_sdk/catalog/base.py

@@ -0,0 +1,57 @@
+# (C) 2022 GoodData Corporation
+from __future__ import annotations
+
+from typing import Any, Dict, Type, TypeVar
+
+import attr
+from cattrs import structure
+
+T = TypeVar("T", bound="Base")
+
+
+@attr.s
+class Base:
+    @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)
+
+    @classmethod
+    def from_dict(cls: Type[T], data: Dict[str, Any], camel_case: bool = True) -> T:
+        """
+        Creates object from dictionary. It needs to be specified if the dictionary is in camelCase or snake_case.
+        """
+        # This branch does not have to exist, but in case of camel_case=False it can perform fewer calls
+        if not camel_case:
+            return structure(data, cls)
+        client_object = cls.client_class().from_dict(data, camel_case)
+        return cls.from_api(client_object)
+
+    def to_dict(self, camel_case: bool = True) -> Dict[str, Any]:
+        """
+        Converts object into dictionary. Optional argument if the dictionary should be camelCase or snake_case can be
+        specified.
+        """
+        # This branch does not have to exist, but in case of camel_case=False it can perform fewer calls
+        if not camel_case:
+            return self._get_snake_dict()
+        return self.to_api().to_dict(camel_case)
+
+    @staticmethod
+    def _is_attribute_private(attribute: attr.Attribute) -> bool:
+        return attribute.name.startswith("_")
+
+    def _get_snake_dict(self) -> Dict[str, Any]:
+        return attr.asdict(
+            self, filter=lambda attribute, value: value is not None and not self._is_attribute_private(attribute)
+        )
+
+    @staticmethod
+    def client_class() -> Any:
+        return NotImplemented
+
+    def to_api(self) -> Any:
+        dictionary = self._get_snake_dict()
+        return self.client_class().from_dict(dictionary, camel_case=False)

gooddata-sdk/gooddata_sdk/catalog/data_source/action_requests/ldm_request.py

@@ -1,66 +1,30 @@
 # (C) 2022 GoodData Corporation
 from __future__ import annotations
 
-from typing import Any
+from typing import Optional, Type
+
+import attr
 
 from gooddata_metadata_client.model.generate_ldm_request import GenerateLdmRequest
+from gooddata_sdk.catalog.base import Base
 
 
-class CatalogGenerateLdmRequest:
-    def __init__(
-        self,
-        separator: str,
-        generate_long_ids: bool = None,
-        table_prefix: str = None,
-        view_prefix: str = None,
-        primary_label_prefix: str = None,
-        secondary_label_prefix: str = None,
-        fact_prefix: str = None,
-        date_granularities: str = None,
-        grain_prefix: str = None,
-        reference_prefix: str = None,
-        grain_reference_prefix: str = None,
-        denorm_prefix: str = None,
-        wdf_prefix: str = None,
-    ):
-        self.separator = separator
-        self.generate_long_ids = generate_long_ids
-        self.table_prefix = table_prefix
-        self.view_prefix = view_prefix
-        self.primary_label_prefix = primary_label_prefix
-        self.secondary_label_prefix = secondary_label_prefix
-        self.fact_prefix = fact_prefix
-        self.date_granularities = date_granularities
-        self.grain_prefix = grain_prefix
-        self.reference_prefix = reference_prefix
-        self.grain_reference_prefix = grain_reference_prefix
-        self.denorm_prefix = denorm_prefix
-        self.wdf_prefix = wdf_prefix
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogGenerateLdmRequest(Base):
+    separator: str = "__"
+    generate_long_ids: Optional[bool] = None
+    table_prefix: Optional[str] = None
+    view_prefix: Optional[str] = None
+    primary_label_prefix: Optional[str] = None
+    secondary_label_prefix: Optional[str] = None
+    fact_prefix: Optional[str] = None
+    date_granularities: Optional[str] = None
+    grain_prefix: Optional[str] = None
+    reference_prefix: Optional[str] = None
+    grain_reference_prefix: Optional[str] = None
+    denorm_prefix: Optional[str] = None
+    wdf_prefix: Optional[str] = None
 
-    def to_api(self) -> GenerateLdmRequest:
-        kwargs: dict[str, Any] = dict()
-        if self.generate_long_ids:
-            kwargs["generate_long_ids"] = self.generate_long_ids
-        if self.table_prefix:
-            kwargs["table_prefix"] = self.table_prefix
-        if self.view_prefix:
-            kwargs["view_prefix"] = self.view_prefix
-        if self.primary_label_prefix:
-            kwargs["primary_label_prefix"] = self.primary_label_prefix
-        if self.secondary_label_prefix:
-            kwargs["secondary_label_prefix"] = self.secondary_label_prefix
-        if self.fact_prefix:
-            kwargs["fact_prefix"] = self.fact_prefix
-        if self.date_granularities:
-            kwargs["date_granularities"] = self.date_granularities
-        if self.grain_prefix:
-            kwargs["grain_prefix"] = self.grain_prefix
-        if self.reference_prefix:
-            kwargs["reference_prefix"] = self.reference_prefix
-        if self.grain_reference_prefix:
-            kwargs["grain_reference_prefix"] = self.grain_reference_prefix
-        if self.denorm_prefix:
-            kwargs["denorm_prefix"] = self.denorm_prefix
-        if self.wdf_prefix:
-            kwargs["wdf_prefix"] = self.wdf_prefix
-        return GenerateLdmRequest(self.separator, **kwargs)
+    @staticmethod
+    def client_class() -> Type[GenerateLdmRequest]:
+        return GenerateLdmRequest

gooddata-sdk/gooddata_sdk/catalog/data_source/action_requests/scan_model_request.py

@@ -1,32 +1,28 @@
 # (C) 2022 GoodData Corporation
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Optional, Type
+
+import attr
+from attr import field
 
 from gooddata_scan_client.model.scan_request import ScanRequest
+from gooddata_sdk.catalog.base import Base
+
+
+def one_scan_true(instance: CatalogScanModelRequest, *args: Any) -> None:
+    if not instance.scan_views and not instance.scan_tables:
+        raise ValueError("Either scan_tables or scan_views must be True in CatalogScanModelRequest.")
+
 
+@attr.s(auto_attribs=True, kw_only=True)
+class CatalogScanModelRequest(Base):
+    separator: str = "__"
+    scan_tables: bool = field(default=True, validator=one_scan_true)
+    scan_views: bool = field(default=False, validator=one_scan_true)
+    table_prefix: Optional[str] = None
+    view_prefix: Optional[str] = None
 
-class CatalogScanModelRequest:
-    def __init__(
-        self,
-        separator: str = "__",
-        scan_tables: bool = True,
-        scan_views: bool = False,
-        table_prefix: str = None,
-        view_prefix: str = None,
-    ):
-        self.separator = separator
-        self.scan_tables = scan_tables
-        self.scan_views = scan_views
-        self.table_prefix = table_prefix
-        self.view_prefix = view_prefix
-        if not scan_views and not scan_tables:
-            raise ValueError("Either scan_tables or scan_views must be True in CatalogScanModelRequest.")
-
-    def to_api(self) -> ScanRequest:
-        kwargs: dict[str, Any] = dict()
-        if self.table_prefix:
-            kwargs["table_prefix"] = self.table_prefix
-        if self.view_prefix:
-            kwargs["view_prefix"] = self.view_prefix
-        return ScanRequest(separator=self.separator, scan_tables=self.scan_tables, scan_views=self.scan_views, **kwargs)
+    @staticmethod
+    def client_class() -> Type[ScanRequest]:
+        return ScanRequest