dcicutils 8.7.0.1b36__tar.gz → 8.7.0.1b37__tar.gz

{dcicutils-8.7.0.1b36 → dcicutils-8.7.0.1b37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.7.0.1b36
+Version: 8.7.0.1b37
 Summary: Utility package for interacting with the 4DN Data Portal and other 4DN resources
 Home-page: https://github.com/4dn-dcic/utils
 License: MIT

{dcicutils-8.7.0.1b36 → dcicutils-8.7.0.1b37}/dcicutils/portal_object_utils.py

@@ -1,8 +1,6 @@
 from functools import lru_cache
-import re
-from typing import Any, Callable, List, Optional, Tuple, Type, Union
+from typing import List, Optional, Tuple, Type, Union
 from dcicutils.portal_utils import Portal
-from dcicutils.schema_utils import Schema
 
 PortalObject = Type["PortalObject"]  # Forward type reference for type hints.
 
@@ -112,64 +110,3 @@ class PortalObject:
         except Exception:
             pass
         return None, self.identifying_path
-
-    def compare(self, value: Union[dict, PortalObject], consider_link_to: bool = False) -> dict:
-        """
-        Compares this Portal object against the given Portal object value; noting differences values of properites
-        which they have in common; and properties which are in this Portal object and not in the given Portal object;
-        we do NOT check the converse, i.e. properties in the given Portal object which are not in this Portal object.
-        Returns a dictionary with a description of the differences. If the given consider_link_to flag is True then
-        TODO.
-        """
-        def are_properties_equal(property_path: str, property_value_a: Any, property_value_b: Any) -> bool:
-            if property_value_a == property_value_b:
-                return True
-            nonlocal self
-            if (schema := self.schema) and (property_type := Schema.get_property_by_path(schema, property_path)):
-                if link_to := property_type.get("linkTo"):
-                    """
-                    This works basically except not WRT sub/super-types (e.g. CellCultureSample vs Sample);
-                    this is only preferable as it only requires one Portal GET rather than two, as below.
-                    if (a := self._portal.get(f"/{link_to}/{property_value_a}")) and (a.status_code == 200):
-                        if a_identifying_paths := PortalObject(self._portal, a.json()).identifying_paths:
-                            if f"/{link_to}/{property_value_b}" in a_identifying_paths:
-                                return True
-                    """
-                    if a := self._portal.get(f"/{link_to}/{property_value_a}", raw=True):
-                        if (a.status_code == 200) and (a := a.json()):
-                            if b := self._portal.get(f"/{link_to}/{property_value_b}", raw=True):
-                                if (b.status_code == 200) and (b := b.json()):
-                                    return a == b
-            return False
-        return PortalObject._compare(self._data, value.data if isinstance(value, PortalObject) else value,
-                                     compare=are_properties_equal if consider_link_to else None)
-
-    _ARRAY_KEY_REGULAR_EXPRESSION = re.compile(rf"^({Schema._ARRAY_NAME_SUFFIX_CHAR}\d+)$")
-
-    @staticmethod
-    def _compare(a: dict, b: dict, compare: Optional[Callable] = None, _path: Optional[str] = None) -> dict:
-        def key_to_path(key: str) -> Optional[str]:  # noqa
-            nonlocal _path
-            if match := PortalObject._ARRAY_KEY_REGULAR_EXPRESSION.search(key):
-                return f"{_path}{match.group(1)}" if _path else match.group(1)
-            return f"{_path}.{key}" if _path else key
-        def list_to_dictionary(value: list) -> dict:  # noqa
-            result = {}
-            for index, item in enumerate(sorted(value)):  # ignore array order
-                result[f"#{index}"] = item
-            return result
-        diffs = {}
-        for key in a:
-            path = key_to_path(key)
-            if key not in b:
-                diffs[path] = {"value": a[key], "missing_value": True}
-            else:
-                if isinstance(a[key], dict) and isinstance(b[key], dict):
-                    diffs.update(PortalObject._compare(a[key], b[key], compare=compare, _path=path))
-                elif isinstance(a[key], list) and isinstance(b[key], list):
-                    diffs.update(PortalObject._compare(list_to_dictionary(a[key]),
-                                                       list_to_dictionary(b[key]), compare=compare, _path=path))
-                elif a[key] != b[key]:
-                    if not callable(compare) or not compare(path, a[key], b[key]):
-                        diffs[path] = {"value": a[key], "differing_value": b[key]}
-        return diffs

{dcicutils-8.7.0.1b36 → dcicutils-8.7.0.1b37}/dcicutils/schema_utils.py

@@ -1,6 +1,4 @@
-import os
-from typing import Any, Dict, List, Optional, Tuple
-from dcicutils.misc_utils import to_camel_case
+from typing import Any, Dict, List
 
 
 class JsonSchemaConstants:
@@ -185,85 +183,3 @@ def get_one_of_formats(schema: Dict[str, Any]) -> List[str]:
         for one_of_schema in get_one_of(schema)
         if get_format(one_of_schema)
     ]
-
-
-class Schema:
-
-    def __init__(self, schema: dict, schema_type: Optional[str] = None) -> None:
-        self._data = schema if isinstance(schema, dict) else (schema.data if isinstance(schema, Schema) else {})
-        self._type = (isinstance(schema_type, str) and schema_type) or Schema.type_name(self._data.get("title", ""))
-
-    @property
-    def data(self) -> dict:
-        return self._data
-
-    @property
-    def type(self) -> str:
-        return self._type
-
-    @staticmethod
-    def type_name(value: str) -> Optional[str]:  # File or other name.
-        if isinstance(value, str) and (value := os.path.basename(value.replace(" ", ""))):
-            return to_camel_case(value[0:dot] if (dot := value.rfind(".")) >= 0 else value)
-
-    def property_by_path(self, property_path: str) -> Optional[dict]:
-        """
-        Looks for the given property path within this Portal schema and returns its dictionary value.
-        This given property path can be either a simple property name, or a series of dot-separated
-        property names representing nested (object) properties; and/or the property names may be
-        suffixed with a pound (#) characteter, optionally followed by an integer, representing an
-        array type property and its optional array index (this integer, if specified, is ignored
-        for the purposes of this function, but it may have been created by another process/function,
-        for example by PortalObject.compare). If the property is not found  then None is returned.
-        """
-        return Schema.get_property_by_path(self._data, property_path)
-
-    _ARRAY_NAME_SUFFIX_CHAR = "#"
-    _DOTTED_NAME_DELIMITER_CHAR = "."
-
-    @staticmethod
-    def get_property_by_path(schema: dict, property_path: str) -> Optional[dict]:
-        if not isinstance(schema, dict) or not isinstance(property_path, str):
-            return None
-        elif not (schema_properties := schema.get("properties")):
-            return None
-        property_paths = property_path.split(Schema._DOTTED_NAME_DELIMITER_CHAR)
-        for property_index, property_name in enumerate(property_paths):
-            property_name, array_specifiers = Schema._unarrayize_property_name(property_name)
-            if not (property_value := schema_properties.get(property_name)):
-                return None
-            elif (property_type := property_value.get("type")) == "object":
-                property_paths_tail = Schema._DOTTED_NAME_DELIMITER_CHAR.join(property_paths[property_index + 1:])
-                return Schema.get_property_by_path(property_value, property_paths_tail)
-            elif (property_type := property_value.get("type")) == "array":
-                if not array_specifiers:
-                    if property_index == len(property_paths) - 1:
-                        return property_value
-                    return None
-                for array_index in range(len(array_specifiers)):
-                    if property_type != "array":
-                        return None
-                    elif not (array_items := property_value.get("items")):
-                        return None
-                    property_type = (property_value := array_items).get("type")
-                if property_type == "object":
-                    if property_index == len(property_paths) - 1:
-                        return property_value
-                    property_paths_tail = Schema._DOTTED_NAME_DELIMITER_CHAR.join(property_paths[property_index + 1:])
-                    return Schema.get_property_by_path(property_value, property_paths_tail)
-        return property_value
-
-    @staticmethod
-    def _unarrayize_property_name(property_name: str) -> Tuple[str, Optional[List[int]]]:
-        if len(components := (property_name := property_name.strip()).split(Schema._ARRAY_NAME_SUFFIX_CHAR)) < 2:
-            return property_name, None
-        unarrayized_property_name = components[0].strip()
-        array_specifiers = []
-        for component in components[1:]:
-            if component.isdigit():
-                array_specifiers.append(int(component))
-            elif component == "":
-                array_specifiers.append(0)
-            else:
-                return property_name, None
-        return unarrayized_property_name, array_specifiers

{dcicutils-8.7.0.1b36 → dcicutils-8.7.0.1b37}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.7.0.1b36"  # TODO: To become 8.7.1
+version = "8.7.0.1b37"  # TODO: To become 8.7.1
 description = "Utility package for interacting with the 4DN Data Portal and other 4DN resources"
 authors = ["4DN-DCIC Team <support@4dnucleome.org>"]
 license = "MIT"