Revert "Merge pull request gooddata#961 from Tjev/cq-1080"

This reverts commit c11a4d2, reversing
changes made to b1e24a7.

Author: Tjev

gooddata-sdk/gooddata_sdk/utils.py

@@ -9,7 +9,7 @@
 from enum import Enum, auto
 from pathlib import Path
 from shutil import rmtree
-from typing import Any, Callable, NamedTuple, Optional, Union, cast, no_type_check
+from typing import Any, Callable, NamedTuple, Union, cast, no_type_check
 from warnings import warn
 from xml.etree import ElementTree as ET
 
@@ -43,25 +43,6 @@ class HttpMethod(Enum):
     PATCH = auto()
 
 
-class ObjRefType(Enum):
-    """Enum representing valid tiger object reference types."""
-
-    ATTRIBUTE = "attribute"
-    METRIC = "metric"
-    LABEL = "label"
-    DATASET = "dataset"
-    FACT = "fact"
-
-
-UI_TO_TIGER_REF_TYPE = {
-    "attribute": ObjRefType.ATTRIBUTE,
-    "measure": ObjRefType.METRIC,
-    "displayForm": ObjRefType.LABEL,
-    "dataSet": ObjRefType.DATASET,
-    "fact": ObjRefType.FACT,
-}
-
-
 def id_obj_to_key(id_obj: IdObjType) -> str:
     """
     Given an object containing an id+type pair, this function will return a string key.
@@ -415,47 +396,28 @@ def read_json(path: Union[str, Path]) -> Any:
         return json.loads(f.read())
 
 
-def ref_extract_obj_id(ref: dict[str, Any], default_type: Optional[ObjRefType] = None) -> ObjId:
+def ref_extract_obj_id(ref: dict[str, Any]) -> ObjId:
     """
     Extracts ObjId from a ref dictionary.
-
-    The ref dictionary will most likely conform to one of two forms:
-    - ui-sdk -> ref: { identifier: str, type: str }
-    - tiger -> ref: { identifier: { id: str, type: str } }
-
     :param ref: the ref to extract from
-    :param default_type: the type of the object to fall back to in case of string identifier
     :return: the extracted ObjId
     :raises ValueError: if the ref is not an identifier
     """
-    identifier = ref.get("identifier")
-    if not identifier:
-        raise ValueError("invalid ref. must be identifier")
-
-    if isinstance(identifier, str):
-        if default_type:
-            return ObjId(id=identifier, type=default_type.value)
-
-        ui_type = ref.get("type")
-        if not ui_type or ui_type not in UI_TO_TIGER_REF_TYPE:
-            raise ValueError("UI objRef type is not recognized and fallback type is not provided")
-
-        converted_type = UI_TO_TIGER_REF_TYPE[ui_type].value
-        return ObjId(id=identifier, type=converted_type)
+    if "identifier" in ref:
+        return ObjId(id=ref["identifier"]["id"], type=ref["identifier"]["type"])
 
-    return ObjId(id=identifier["id"], type=identifier["type"])
+    raise ValueError("invalid ref. must be identifier")
 
 
-def ref_extract(ref: dict[str, Any], default_type: Optional[ObjRefType] = None) -> Union[str, ObjId]:
+def ref_extract(ref: dict[str, Any]) -> Union[str, ObjId]:
     """
     Extracts an object id from a ref dictionary: either an identifier or a localIdentifier.
     :param ref: the ref to extract from
-    :param default_type: ref type to use in case of ui-sdk form of identifier object
     :return: thr extracted object id
     :raises ValueError: if the ref is not an identifier or localIdentifier
     """
     try:
-        return ref_extract_obj_id(ref, default_type)
+        return ref_extract_obj_id(ref)
     except ValueError:
         pass
 

gooddata-sdk/gooddata_sdk/visualization.py

@@ -29,15 +29,7 @@
     PopDatesetMetric,
     SimpleMetric,
 )
-from gooddata_sdk.utils import (
-    IdObjType,
-    ObjRefType,
-    SideLoads,
-    load_all_entities,
-    ref_extract,
-    ref_extract_obj_id,
-    safeget,
-)
+from gooddata_sdk.utils import IdObjType, SideLoads, load_all_entities, ref_extract, ref_extract_obj_id, safeget
 
 #
 # Conversion from types stored in visualization into the gooddata_afm_client models.
@@ -174,30 +166,23 @@ def _convert_filter_to_computable(filter_obj: dict[str, Any]) -> Filter:
         # fallback to use URIs; SDK may be able to create filter with attr elements as uris...
         in_values = f["in"]["values"] if "values" in f["in"] else f["in"]["uris"]
 
-        return PositiveAttributeFilter(
-            label=ref_extract(f["displayForm"], ObjRefType.LABEL),
-            values=in_values,
-        )
+        return PositiveAttributeFilter(label=ref_extract(f["displayForm"]), values=in_values)
 
     elif "negativeAttributeFilter" in filter_obj:
         f = filter_obj["negativeAttributeFilter"]
         # fallback to use URIs; SDK may be able to create filter with attr elements as uris...
         not_in_values = f["notIn"]["values"] if "values" in f["notIn"] else f["notIn"]["uris"]
 
-        return NegativeAttributeFilter(
-            label=ref_extract(f["displayForm"], ObjRefType.LABEL),
-            values=not_in_values,
-        )
-
+        return NegativeAttributeFilter(label=ref_extract(f["displayForm"]), values=not_in_values)
     elif "relativeDateFilter" in filter_obj:
         f = filter_obj["relativeDateFilter"]
 
         # there is filter present, but uses all time
         if ("from" not in f) or ("to" not in f):
-            return AllTimeFilter(ref_extract_obj_id(f["dataSet"], ObjRefType.DATASET))
+            return AllTimeFilter(ref_extract_obj_id(f["dataSet"]))
 
         return RelativeDateFilter(
-            dataset=ref_extract_obj_id(f["dataSet"], ObjRefType.DATASET),
+            dataset=ref_extract_obj_id(f["dataSet"]),
             granularity=_GRANULARITY_CONVERSION[f["granularity"]],
             from_shift=f["from"],
             to_shift=f["to"],
@@ -206,12 +191,7 @@ def _convert_filter_to_computable(filter_obj: dict[str, Any]) -> Filter:
     elif "absoluteDateFilter" in filter_obj:
         f = filter_obj["absoluteDateFilter"]
 
-        return AbsoluteDateFilter(
-            dataset=ref_extract_obj_id(f["dataSet"], ObjRefType.DATASET),
-            from_date=f["from"],
-            to_date=f["to"],
-        )
-
+        return AbsoluteDateFilter(dataset=ref_extract_obj_id(f["dataSet"]), from_date=f["from"], to_date=f["to"])
     elif "measureValueFilter" in filter_obj:
         f = filter_obj["measureValueFilter"]
 
@@ -231,7 +211,6 @@ def _convert_filter_to_computable(filter_obj: dict[str, Any]) -> Filter:
                 values=c["value"],
                 treat_nulls_as=treat_values_as_null,
             )
-
         elif "range" in condition:
             c = condition["range"]
             treat_values_as_null = c.get("treatNullValuesAs")
@@ -241,7 +220,6 @@ def _convert_filter_to_computable(filter_obj: dict[str, Any]) -> Filter:
                 values=(c["from"], c["to"]),
                 treat_nulls_as=treat_values_as_null,
             )
-
     elif "rankingFilter" in filter_obj:
         f = filter_obj["rankingFilter"]
         # mypy is unable to automatically convert Union[str, ObjId] to Union[str, ObjId, Attribute, Metric]
@@ -276,20 +254,15 @@ def _convert_metric_to_computable(metric: dict[str, Any]) -> Metric:
 
         return SimpleMetric(
             local_id=local_id,
-            item=ref_extract_obj_id(d["item"], ObjRefType.FACT),
+            item=ref_extract_obj_id(d["item"]),
             aggregation=aggregation,
             compute_ratio=compute_ratio,
             filters=filters,
         )
 
     elif "popMeasureDefinition" in measure_def:
         d = measure_def["popMeasureDefinition"]
-        date_attributes = [
-            PopDate(
-                attribute=ref_extract_obj_id(d["popAttribute"], ObjRefType.ATTRIBUTE),
-                periods_ago=1,
-            ),
-        ]
+        date_attributes = [PopDate(attribute=ref_extract_obj_id(d["popAttribute"]), periods_ago=1)]
 
         return PopDateMetric(
             local_id=local_id,
@@ -300,9 +273,7 @@ def _convert_metric_to_computable(metric: dict[str, Any]) -> Metric:
     elif "previousPeriodMeasure" in measure_def:
         d = measure_def["previousPeriodMeasure"]
 
-        date_datasets = [
-            PopDateDataset(ref_extract(dd["dataSet"], ObjRefType.DATASET), dd["periodsAgo"]) for dd in d["dateDataSets"]
-        ]
+        date_datasets = [PopDateDataset(ref_extract(dd["dataSet"]), dd["periodsAgo"]) for dd in d["dateDataSets"]]
 
         return PopDatesetMetric(
             local_id=local_id,
@@ -423,11 +394,7 @@ def show_all_values(self) -> Optional[bool]:
         return self._a.get("showAllValues")
 
     def as_computable(self) -> Attribute:
-        return Attribute(
-            local_id=self.local_id,
-            label=ref_extract(self.label, ObjRefType.LABEL),
-            show_all_values=self.show_all_values,
-        )
+        return Attribute(local_id=self.local_id, label=ref_extract(self.label), show_all_values=self.show_all_values)
 
     def __str__(self) -> str:
         return self.__repr__()