dcicutils 8.7.1.1b9__tar.gz → 8.7.1.1b12__tar.gz

{dcicutils-8.7.1.1b9 → dcicutils-8.7.1.1b12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.7.1.1b9
+Version: 8.7.1.1b12
 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.1.1b9 → dcicutils-8.7.1.1b12}/dcicutils/portal_object_utils.py

@@ -1,6 +1,5 @@
 from copy import deepcopy
 from functools import lru_cache
-import re
 from typing import Any, List, Optional, Tuple, Type, Union
 from dcicutils.data_readers import RowReader
 from dcicutils.misc_utils import create_readonly_object
@@ -14,28 +13,28 @@ class PortalObject:
 
     _PROPERTY_DELETION_SENTINEL = RowReader.CELL_DELETION_SENTINEL
 
-    def __init__(self, portal: Portal, portal_object: dict, portal_object_type: Optional[str] = None) -> None:
-        self._portal = portal
+    def __init__(self, portal_object: dict, portal: Portal = None, type: Optional[str] = None) -> None:
         self._data = portal_object
-        self._type = portal_object_type if isinstance(portal_object_type, str) and portal_object_type else None
+        self._portal = portal
+        self._type = type if isinstance(type, str) and type else None
 
     @property
-    def data(self):
+    def data(self) -> dict:
         return self._data
 
     @property
-    def portal(self):
+    def portal(self) -> Optional[Portal]:
         return self._portal
 
     @property
     @lru_cache(maxsize=1)
-    def type(self):
+    def type(self) -> Optional[str]:
         return self._type or Portal.get_schema_type(self._data)
 
     @property
     @lru_cache(maxsize=1)
-    def types(self):
-        return self._type or Portal.get_schema_types(self._data)
+    def types(self) -> Optional[List[str]]:
+        return [self._type] if self._type else Portal.get_schema_types(self._data)
 
     @property
     @lru_cache(maxsize=1)
@@ -44,22 +43,22 @@ class PortalObject:
 
     @property
     @lru_cache(maxsize=1)
-    def schema(self):
-        return self._portal.get_schema(self.type)
+    def schema(self) -> Optional[dict]:
+        return self._portal.get_schema(self.type) if self._portal else None
 
     def copy(self) -> PortalObject:
-        return PortalObject(self.portal, deepcopy(self.data), self.type)
+        return PortalObject(deepcopy(self.data), portal=self.portal, type=self.type)
 
     @property
     @lru_cache(maxsize=1)
-    def identifying_properties(self) -> List[str]:
+    def identifying_properties(self) -> Optional[List[str]]:
         """
         Returns the list of all identifying property names of this Portal object which actually have values.
         Implicitly include "uuid" and "identifier" properties as identifying properties if they are actually
         properties in the object schema, and favor these (first); defavor "aliases"; no other ordering defined.
         """
         if not (schema := self.schema) or not (schema_identifying_properties := schema.get("identifyingProperties")):
-            return []
+            return None
         identifying_properties = []
         for identifying_property in schema_identifying_properties:
             if identifying_property not in ["uuid", "identifier", "aliases"]:
@@ -71,17 +70,21 @@ class PortalObject:
             identifying_properties.insert(0, "uuid")
         if "aliases" in schema_identifying_properties and self._data.get("aliases"):
             identifying_properties.append("aliases")
-        return identifying_properties
+        return identifying_properties or None
 
     @property
     @lru_cache(maxsize=1)
-    def identifying_paths(self) -> List[str]:
+    def identifying_paths(self) -> Optional[List[str]]:
         """
         Returns a list of the possible Portal URL paths identifying this Portal object.
         """
-        if not (identifying_properties := self.identifying_properties):
-            return []
         identifying_paths = []
+        if not (identifying_properties := self.identifying_properties):
+            if self.uuid:
+                if self.type:
+                    identifying_paths.append(f"/{self.type}/{self.uuid}")
+                identifying_paths.append(f"/{self.uuid}")
+            return identifying_paths
         for identifying_property in identifying_properties:
             if (identifying_value := self._data.get(identifying_property)):
                 if identifying_property == "uuid":
@@ -96,12 +99,14 @@ class PortalObject:
                 # not work but /FileSet/UW_FILE-SET_COLO-829BL_HI-C_1 does work.
                 elif isinstance(identifying_value, list):
                     for identifying_value_item in identifying_value:
-                        identifying_paths.append(f"/{self.type}/{identifying_value_item}")
+                        if self.type:
+                            identifying_paths.append(f"/{self.type}/{identifying_value_item}")
                         identifying_paths.append(f"/{identifying_value_item}")
                 else:
-                    identifying_paths.append(f"/{self.type}/{identifying_value}")
+                    if self.type:
+                        identifying_paths.append(f"/{self.type}/{identifying_value}")
                     identifying_paths.append(f"/{identifying_value}")
-        return identifying_paths
+        return identifying_paths or None
 
     @property
     @lru_cache(maxsize=1)
@@ -118,9 +123,11 @@ class PortalObject:
 
     def _lookup(self, raw: bool = False) -> Tuple[Optional[PortalObject], Optional[str]]:
         try:
-            for identifying_path in self.identifying_paths:
-                if (value := self._portal.get(identifying_path, raw=raw)) and (value.status_code == 200):
-                    return PortalObject(self._portal, value.json(), self.type if raw else None), identifying_path
+            if identifying_paths := self.identifying_paths:
+                for identifying_path in identifying_paths:
+                    if (value := self._portal.get(identifying_path, raw=raw)) and (value.status_code == 200):
+                        return PortalObject(value.json(),
+                                            portal=self._portal, type=self.type if raw else None), identifying_path
         except Exception:
             pass
         return None, self.identifying_path
@@ -139,8 +146,6 @@ class PortalObject:
             return {}
         return PortalObject._compare(this_data, comparing_data)
 
-    _ARRAY_KEY_REGULAR_EXPRESSION = re.compile(rf"^({Schema._ARRAY_NAME_SUFFIX_CHAR}\d+)$")
-
     @staticmethod
     def _compare(a: Any, b: Any, _path: Optional[str] = None) -> dict:
         def diff_creating(value: Any) -> object:  # noqa
@@ -175,7 +180,7 @@ class PortalObject:
                         else:
                             if index < len(b):
                                 diffs[path] = diff_deleting(b[index])
-                elif len(b) < index:
+                elif index < len(b):
                     diffs.update(PortalObject._compare(a[index], b[index], _path=path))
                 else:
                     diffs[path] = diff_creating(a[index])

{dcicutils-8.7.1.1b9 → dcicutils-8.7.1.1b12}/dcicutils/portal_utils.py

@@ -28,7 +28,7 @@ class Portal:
     """
     This is meant to be an Über wrapper for Portal access. It can be created in a variety of ways:
     1. From a (Portal) .ini file (e.g. development.ini).
-    2. From a key dictionary, containing "key" and "secret" property values.
+    2. From a key dictionary, containing "key" and "secret" and (optional) "server" property values.
     3. From a key pair tuple, containing (in order) a key and secret values.
     4. From a keys .json file residing in ~/.{app}-keys.json where the given "app" value is either "smaht", "cgap",
        or "fourfront"; where is assumed to contain a dictionary with a key for the given "env" value, e.g. smaht-local;

{dcicutils-8.7.1.1b9 → dcicutils-8.7.1.1b12}/dcicutils/schema_utils.py

@@ -189,9 +189,9 @@ def get_one_of_formats(schema: Dict[str, Any]) -> List[str]:
 
 class Schema:
 
-    def __init__(self, schema: dict, schema_type: Optional[str] = None) -> None:
+    def __init__(self, schema: dict, 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", ""))
+        self._type = (type if isinstance(type, str) else "") or Schema.type_name(self._data.get("title", ""))
 
     @property
     def data(self) -> dict:

{dcicutils-8.7.1.1b9 → dcicutils-8.7.1.1b12}/dcicutils/structured_data.py

@@ -16,6 +16,7 @@ from dcicutils.misc_utils import (create_dict, create_readonly_object, load_json
                                   split_string, to_boolean, to_enum, to_float, to_integer, VirtualApp)
 from dcicutils.portal_object_utils import PortalObject
 from dcicutils.portal_utils import Portal as PortalBase
+from dcicutils.schema_utils import Schema as SchemaBase
 from dcicutils.zip_utils import unpack_gz_file_to_temporary_file, unpack_files
 
 
@@ -154,7 +155,7 @@ class StructuredDataSet:
                 if not diffs.get(object_type):
                     diffs[object_type] = []
                 for portal_object in self.data[object_type]:
-                    portal_object = PortalObject(self.portal, portal_object, object_type)
+                    portal_object = PortalObject(portal_object, portal=self.portal, type=object_type)
                     existing_object, identifying_path = portal_object.lookup(include_identifying_path=True, raw=True)
                     if existing_object:
                         object_diffs = portal_object.compare(existing_object, consider_refs=True, resolved_refs=refs)
@@ -363,11 +364,12 @@ class _StructuredRowTemplate:
         return structured_row_template
 
 
-class Schema:
+class Schema(SchemaBase):
 
     def __init__(self, schema_json: dict, portal: Optional[Portal] = None) -> None:
-        self._data = schema_json if isinstance(schema_json, dict) else {}
-        self._type = Schema.type_name(schema_json.get("title", ""))
+        super().__init__(schema_json)
+#       self._data = schema_json if isinstance(schema_json, dict) else {}
+#       self._type = Schema.type_name(schema_json.get("title", ""))
         self._portal = portal  # Needed only to resolve linkTo references.
         self._map_value_functions = {
             "boolean": self._map_function_boolean,
@@ -380,13 +382,13 @@ class Schema:
         self._unresolved_refs = []
         self._typeinfo = self._create_typeinfo(schema_json)
 
-    @property
-    def data(self) -> dict:
-        return self._data
+#   @property
+#   def data(self) -> dict:
+#       return self._data
 
-    @property
-    def type(self) -> str:
-        return self._type
+#   @property
+#   def type(self) -> str:
+#       return self._type
 
     @staticmethod
     def load_by_name(name: str, portal: Portal) -> Optional[dict]:

{dcicutils-8.7.1.1b9 → dcicutils-8.7.1.1b12}/pyproject.toml

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