dcicutils 8.7.1.1b3__tar.gz → 8.7.1.1b5__tar.gz

{dcicutils-8.7.1.1b3 → dcicutils-8.7.1.1b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.7.1.1b3
+Version: 8.7.1.1b5
 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.1b3 → dcicutils-8.7.1.1b5}/dcicutils/data_readers.py

@@ -7,10 +7,21 @@ from dcicutils.misc_utils import create_dict, right_trim
 # Forward type references for type hints.
 Excel = Type["Excel"]
 
+# Cell values(s) indicating property deletion.
+_CELL_DELETION_VALUES = ["*delete*"]
+
+
+# Special cell deletion sentinel value (note make sure on deepcopy it remains the same).
+class _CellDeletionSentinal(str):
+    def __new__(cls):
+        return super(_CellDeletionSentinal, cls).__new__(cls, _CELL_DELETION_VALUES[0])
+    def __deepcopy__(self, memo):  # noqa
+        return self
+
 
 class RowReader(abc.ABC):
 
-    DELETION_CELL_VALUE = "*delete*"
+    CELL_DELETION_SENTINEL = _CellDeletionSentinal()
 
     def __init__(self):
         self.header = None
@@ -50,8 +61,8 @@ class RowReader(abc.ABC):
     def cell_value(self, value: Optional[Any]) -> str:
         if value is None:
             return ""
-        elif (value := str(value).strip()) == RowReader.DELETION_CELL_VALUE:
-            return RowReader.DELETION_CELL_VALUE
+        elif (value := str(value).strip()) in _CELL_DELETION_VALUES:
+            return RowReader.CELL_DELETION_SENTINEL
         else:
             return value
 

{dcicutils-8.7.1.1b3 → dcicutils-8.7.1.1b5}/dcicutils/misc_utils.py

@@ -1148,16 +1148,22 @@ def remove_suffix(suffix: str, text: str, required: bool = False):
     return text[:len(text)-len(suffix)]
 
 
-def remove_empty_properties(data: Optional[Union[list, dict]]) -> None:
+def remove_empty_properties(data: Optional[Union[list, dict]],
+                            isempty: Optional[Callable] = None,
+                            isempty_array_element: Optional[Callable] = None) -> None:
+    def _isempty(value: Any) -> bool:  # noqa
+        return isempty(value) if callable(isempty) else value in [None, "", {}, []]
     if isinstance(data, dict):
         for key in list(data.keys()):
-            if (value := data[key]) in [None, "", {}, []]:
+            if _isempty(value := data[key]):
                 del data[key]
             else:
-                remove_empty_properties(value)
+                remove_empty_properties(value, isempty=isempty, isempty_array_element=isempty_array_element)
     elif isinstance(data, list):
         for item in data:
-            remove_empty_properties(item)
+            remove_empty_properties(item, isempty=isempty, isempty_array_element=isempty_array_element)
+        if callable(isempty_array_element):
+            data[:] = [item for item in data if not isempty_array_element(item)]
 
 
 class ObsoleteError(Exception):

dcicutils-8.7.1.1b5/dcicutils/portal_object_utils.py

@@ -0,0 +1,234 @@
+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.portal_utils import Portal
+from dcicutils.schema_utils import Schema
+
+PortalObject = Type["PortalObject"]  # Forward type reference for type hints.
+
+
+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
+        self._data = portal_object
+        self._type = portal_object_type if isinstance(portal_object_type, str) and portal_object_type else None
+
+    @property
+    def data(self):
+        return self._data
+
+    @property
+    def portal(self):
+        return self._portal
+
+    @property
+    @lru_cache(maxsize=1)
+    def type(self):
+        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)
+
+    @property
+    @lru_cache(maxsize=1)
+    def uuid(self) -> Optional[str]:
+        return self._data.get("uuid") if isinstance(self._data, dict) else None
+
+    @property
+    @lru_cache(maxsize=1)
+    def schema(self):
+        return self._portal.get_schema(self.type)
+
+    def copy(self) -> PortalObject:
+        return PortalObject(self.portal, deepcopy(self.data), self.type)
+
+    @property
+    @lru_cache(maxsize=1)
+    def identifying_properties(self) -> 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 []
+        identifying_properties = []
+        for identifying_property in schema_identifying_properties:
+            if identifying_property not in ["uuid", "identifier", "aliases"]:
+                if self._data.get(identifying_property):
+                    identifying_properties.append(identifying_property)
+        if self._data.get("identifier"):
+            identifying_properties.insert(0, "identifier")
+        if self._data.get("uuid"):
+            identifying_properties.insert(0, "uuid")
+        if "aliases" in schema_identifying_properties and self._data.get("aliases"):
+            identifying_properties.append("aliases")
+        return identifying_properties
+
+    @property
+    @lru_cache(maxsize=1)
+    def identifying_paths(self) -> 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 = []
+        for identifying_property in identifying_properties:
+            if (identifying_value := self._data.get(identifying_property)):
+                if identifying_property == "uuid":
+                    identifying_paths.append(f"/{self.type}/{identifying_value}")
+                    identifying_paths.append(f"/{identifying_value}")
+                # For now at least we include the path both with and without the schema type component,
+                # as for some identifying values, it works (only) with, and some, it works (only) without.
+                # For example: If we have FileSet with "accession", an identifying property, with value
+                # SMAFSFXF1RO4 then /SMAFSFXF1RO4 works but /FileSet/SMAFSFXF1RO4 does not; and
+                # conversely using "submitted_id", also an identifying property, with value
+                # UW_FILE-SET_COLO-829BL_HI-C_1 then /UW_FILE-SET_COLO-829BL_HI-C_1 does
+                # 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}")
+                        identifying_paths.append(f"/{identifying_value_item}")
+                else:
+                    identifying_paths.append(f"/{self.type}/{identifying_value}")
+                    identifying_paths.append(f"/{identifying_value}")
+        return identifying_paths
+
+    @property
+    @lru_cache(maxsize=1)
+    def identifying_path(self) -> Optional[str]:
+        if identifying_paths := self.identifying_paths:
+            return identifying_paths[0]
+
+    def lookup(self, include_identifying_path: bool = False,
+               raw: bool = False) -> Optional[Union[Tuple[PortalObject, str], PortalObject]]:
+        return self._lookup(raw=raw) if include_identifying_path else self._lookup(raw=raw)[0]
+
+    def lookup_identifying_path(self) -> Optional[str]:
+        return self._lookup()[1]
+
+    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
+        except Exception:
+            pass
+        return None, self.identifying_path
+
+    def compare(self, value: Union[dict, PortalObject],
+                consider_refs: bool = False, resolved_refs: List[dict] = None) -> dict:
+        if consider_refs and isinstance(resolved_refs, list):
+            this_data = self.normalized_refs(refs=resolved_refs).data
+        else:
+            this_data = self.data
+        if isinstance(value, PortalObject):
+            comparing_data = value.data
+        elif isinstance(value, dict):
+            comparing_data = value
+        else:
+            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:
+        diffs = {}
+        if isinstance(a, dict) and isinstance(b, dict):
+            for key in a:
+                path = f"{_path}.{key}" if _path else key
+                if key not in b:
+                    if a[key] != PortalObject._PROPERTY_DELETION_SENTINEL:
+                        diffs[path] = {"value": a[key], "creating_value": True}
+                else:
+                    diffs.update(PortalObject._compare(a[key], b[key], _path=path))
+        elif isinstance(a, list) and isinstance(b, list):
+            # Ignore order of array elements; not absolutely technically correct but suits our purpose.
+            for index in range(len(a)):
+                path = f"{_path or ''}#{index}"
+                if not isinstance(a[index], dict) and not isinstance(a[index], list):
+                    if a[index] not in b:
+                        if a[index] != PortalObject._PROPERTY_DELETION_SENTINEL:
+                            if index < len(b):
+                                diffs[path] = {"value": a[index], "updating_value": b[index]}
+                            else:
+                                diffs[path] = {"value": a[index], "creating_value": True}
+                        else:
+                            if index < len(b):
+                                diffs[path] = {"value": b[index], "deleting_value": True}
+                elif len(b) < index:
+                    diffs.update(PortalObject._compare(a[index], b[index], _path=path))
+                else:
+                    diffs[path] = {"value": a[index], "creating_value": True}
+        elif a != b:
+            if a == PortalObject._PROPERTY_DELETION_SENTINEL:
+                diffs[_path] = {"value": b, "deleting_value": True}
+            else:
+                diffs[_path] = {"value": a, "updating_value": b}
+        return diffs
+
+    def normalize_refs(self, refs: List[dict]) -> None:
+        """
+        Turns any (linkTo) references which are paths (e.g. /SubmissionCenter/uwsc_gcc) within
+        this Portal object into the uuid style reference (e.g. d1b67068-300f-483f-bfe8-63d23c93801f),
+        based on the given "refs" list which is assumed to be a list of dictionaries, where each
+        contains a "path" and a "uuid" property; this list is typically (for our first usage of
+        this function) the value of structured_data.StructuredDataSet.resolved_refs_with_uuid.
+        Change is made to this Portal object in place; use normalized_refs function to make a copy.
+        If there are no "refs" (None or empty) then the references will be looked up via Portal calls.
+        """
+        PortalObject._normalize_refs(self.data, refs=refs, schema=self.schema, portal=self.portal)
+
+    def normalized_refs(self, refs: List[dict]) -> PortalObject:
+        """
+        Same as normalize_ref but does not make this change to this Portal object in place,
+        rather it returns a new instance of this Portal object wrapped in a new PortalObject.
+        """
+        portal_object = self.copy()
+        portal_object.normalize_refs(refs)
+        return portal_object
+
+    @staticmethod
+    def _normalize_refs(value: Any, refs: List[dict], schema: dict, portal: Portal, _path: Optional[str] = None) -> Any:
+        if not value or not isinstance(schema, dict):
+            return value
+        if isinstance(value, dict):
+            for key in value:
+                path = f"{_path}.{key}" if _path else key
+                value[key] = PortalObject._normalize_refs(value[key], refs=refs,
+                                                          schema=schema, portal=portal, _path=path)
+        elif isinstance(value, list):
+            for index in range(len(value)):
+                path = f"{_path or ''}#{index}"
+                value[index] = PortalObject._normalize_refs(value[index], refs=refs,
+                                                            schema=schema, portal=portal, _path=path)
+        elif value_type := Schema.get_property_by_path(schema, _path):
+            if link_to := value_type.get("linkTo"):
+                ref_path = f"/{link_to}/{value}"
+                if not isinstance(refs, list):
+                    refs = []
+                if ref_uuids := [ref.get("uuid") for ref in refs if ref.get("path") == ref_path]:
+                    ref_uuid = ref_uuids[0]
+                else:
+                    ref_uuid = None
+                if ref_uuid:
+                    return ref_uuid
+                # Here our (linkTo) reference appears not to be in the given refs; if these refs came
+                # from structured_data.StructuredDataSet.resolved_refs_with_uuid (in the context of
+                # smaht-submitr, which is the typical/first use case for this function) then this could
+                # be because the reference was to an internal object, i.e. another object existing within
+                # the data/spreadsheet being submitted. In any case, we don't have the associated uuid
+                # so let us look it up here.
+                if isinstance(portal, Portal):
+                    if (ref_object := portal.get_metadata(ref_path)) and (ref_uuid := ref_object.get("uuid")):
+                        return ref_uuid
+        return value

{dcicutils-8.7.1.1b3 → dcicutils-8.7.1.1b5}/dcicutils/portal_utils.py

@@ -264,12 +264,12 @@ class Portal:
             add_on = ""
         return get_metadata(obj_id=object_id, vapp=self.vapp, key=self.key, add_on=add_on)
 
-    def patch_metadata(self, object_id: str, data: str) -> Optional[dict]:
+    def patch_metadata(self, object_id: str, data: dict) -> Optional[dict]:
         if self.key:
             return patch_metadata(obj_id=object_id, patch_item=data, key=self.key)
         return self.patch(f"/{object_id}", data).json()
 
-    def post_metadata(self, object_type: str, data: str) -> Optional[dict]:
+    def post_metadata(self, object_type: str, data: dict) -> Optional[dict]:
         if self.key:
             return post_metadata(schema_name=object_type, post_item=data, key=self.key)
         return self.post(f"/{object_type}", data).json()

{dcicutils-8.7.1.1b3 → dcicutils-8.7.1.1b5}/dcicutils/structured_data.py

@@ -46,8 +46,8 @@ class StructuredDataSet:
     def __init__(self, file: Optional[str] = None, portal: Optional[Union[VirtualApp, TestApp, Portal]] = None,
                  schemas: Optional[List[dict]] = None, autoadd: Optional[dict] = None,
                  order: Optional[List[str]] = None, prune: bool = True) -> None:
-        self.data = {}
-        self._portal = Portal(portal, data=self.data, schemas=schemas) if portal else None
+        self._data = {}
+        self._portal = Portal(portal, data=self._data, schemas=schemas) if portal else None
         self._order = order
         self._prune = prune
         self._warnings = {}
@@ -57,6 +57,10 @@ class StructuredDataSet:
         self._autoadd_properties = autoadd if isinstance(autoadd, dict) and autoadd else None
         self._load_file(file) if file else None
 
+    @property
+    def data(self) -> dict:
+        return self._data
+
     @staticmethod
     def load(file: str, portal: Optional[Union[VirtualApp, TestApp, Portal]] = None,
              schemas: Optional[List[dict]] = None, autoadd: Optional[dict] = None,
@@ -64,6 +68,17 @@ class StructuredDataSet:
         return StructuredDataSet(file=file, portal=portal, schemas=schemas, autoadd=autoadd, order=order, prune=prune)
 
     def validate(self, force: bool = False) -> None:
+        def data_without_deleted_properties(data: dict) -> dict:
+            nonlocal self
+            def isempty(value: Any) -> bool:  # noqa
+                if value == RowReader.CELL_DELETION_SENTINEL:
+                    return True
+                return self._prune and value in [None, "", {}, []]
+            def isempty_array_element(value: Any) -> bool:  # noqa
+                return value == RowReader.CELL_DELETION_SENTINEL
+            data = copy.deepcopy(data)
+            remove_empty_properties(data, isempty=isempty, isempty_array_element=isempty_array_element)
+            return data
         if self._validated and not force:
             return
         self._validated = True
@@ -71,6 +86,7 @@ class StructuredDataSet:
             if (schema := Schema.load_by_name(type_name, portal=self._portal)):
                 row_number = 0
                 for data in self.data[type_name]:
+                    data = data_without_deleted_properties(data)
                     row_number += 1
                     if (validation_errors := schema.validate(data)) is not None:
                         for validation_error in validation_errors:
@@ -99,7 +115,11 @@ class StructuredDataSet:
 
     @property
     def resolved_refs(self) -> List[str]:
-        return list(self._resolved_refs)
+        return list([resolved_ref[0] for resolved_ref in self._resolved_refs])
+
+    @property
+    def resolved_refs_with_uuids(self) -> List[str]:
+        return list([{"path": resolved_ref[0], "uuid": resolved_ref[1]} for resolved_ref in self._resolved_refs])
 
     @property
     def upload_files(self) -> List[str]:
@@ -185,10 +205,10 @@ class StructuredDataSet:
     def _add(self, type_name: str, data: Union[dict, List[dict]]) -> None:
         if self._prune:
             remove_empty_properties(data)
-        if type_name in self.data:
-            self.data[type_name].extend([data] if isinstance(data, dict) else data)
+        if type_name in self._data:
+            self._data[type_name].extend([data] if isinstance(data, dict) else data)
         else:
-            self.data[type_name] = [data] if isinstance(data, dict) else data
+            self._data[type_name] = [data] if isinstance(data, dict) else data
 
     def _add_properties(self, structured_row: dict, properties: dict, schema: Optional[dict] = None) -> None:
         for name in properties:
@@ -352,14 +372,6 @@ class Schema:
             errors.append(error.message)
         return errors
 
-    @property
-    def unresolved_refs(self) -> List[dict]:
-        return self._unresolved_refs
-
-    @property
-    def resolved_refs(self) -> List[str]:
-        return list(self._resolved_refs)
-
     def get_typeinfo(self, column_name: str) -> Optional[dict]:
         if isinstance(info := self._typeinfo.get(column_name), str):
             info = self._typeinfo.get(info)
@@ -423,9 +435,14 @@ class Schema:
                 if not (resolved := portal.ref_exists(link_to, value)):
                     self._unresolved_refs.append({"src": src, "error": f"/{link_to}/{value}"})
                 elif len(resolved) > 1:
-                    self._unresolved_refs.append({"src": src, "error": f"/{link_to}/{value}", "types": resolved})
+                    # TODO: Don't think we need this anymore; see TODO on Portal.ref_exists.
+                    self._unresolved_refs.append({
+                        "src": src,
+                        "error": f"/{link_to}/{value}",
+                        "types": [resolved_ref["type"] for resolved_ref in resolved]})
                 else:
-                    self._resolved_refs.add(f"/{link_to}/{value}")
+                    # A resolved-ref set value is a tuple of the reference path and its uuid.
+                    self._resolved_refs.add((f"/{link_to}/{value}", resolved[0].get("uuid")))
             return value
         return lambda value, src: map_ref(value, typeinfo.get("linkTo"), self._portal, src)
 
@@ -617,8 +634,9 @@ class Portal(PortalBase):
 
     def ref_exists(self, type_name: str, value: str) -> List[str]:
         resolved = []
-        if self._ref_exists_single(type_name, value):
-            resolved.append(type_name)
+        is_resolved, resolved_uuid = self._ref_exists_single(type_name, value)
+        if is_resolved:
+            resolved.append({"type": type_name, "uuid": resolved_uuid})
             # TODO: Added this return on 2024-01-14 (dmichaels).
             # Why did I orginally check for multiple existing values?
             # Why not just return right away if I find that the ref exists?
@@ -631,20 +649,23 @@ class Portal(PortalBase):
         if (schemas_super_type_map := self.get_schemas_super_type_map()):
             if (sub_type_names := schemas_super_type_map.get(type_name)):
                 for sub_type_name in sub_type_names:
-                    if self._ref_exists_single(sub_type_name, value):
-                        resolved.append(type_name)
+                    is_resolved, resolved_uuid = self._ref_exists_single(sub_type_name, value)
+                    if is_resolved:
+                        resolved.append({"type": type_name, "uuid": resolved_uuid})
                         # TODO: Added this return on 2024-01-14 (dmichaels). See above TODO.
                         return resolved
         return resolved
 
-    def _ref_exists_single(self, type_name: str, value: str) -> bool:
+    def _ref_exists_single(self, type_name: str, value: str) -> Tuple[bool, Optional[str]]:
         if self._data and (items := self._data.get(type_name)) and (schema := self.get_schema(type_name)):
             iproperties = set(schema.get("identifyingProperties", [])) | {"identifier", "uuid"}
             for item in items:
                 if (ivalue := next((item[iproperty] for iproperty in iproperties if iproperty in item), None)):
                     if isinstance(ivalue, list) and value in ivalue or ivalue == value:
-                        return True
-        return self.get_metadata(f"/{type_name}/{value}") is not None
+                        return True, None
+        if (value := self.get_metadata(f"/{type_name}/{value}")) is None:
+            return False, None
+        return True, value.get("uuid")
 
     @staticmethod
     def create_for_testing(arg: Optional[Union[str, bool, List[dict], dict, Callable]] = None,

{dcicutils-8.7.1.1b3 → dcicutils-8.7.1.1b5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.7.1.1b3"  # TODO: To become 8.7.2
+version = "8.7.1.1b5"  # 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"

dcicutils-8.7.1.1b3/dcicutils/portal_object_utils.py

@@ -1,177 +0,0 @@
-from functools import lru_cache
-import re
-from typing import Any, Callable, 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.
-
-
-class PortalObject:
-
-    def __init__(self, portal: Portal, portal_object: dict, portal_object_type: Optional[str] = None) -> None:
-        self._portal = portal
-        self._data = portal_object
-        self._type = portal_object_type if isinstance(portal_object_type, str) and portal_object_type else None
-
-    @property
-    def data(self):
-        return self._data
-
-    @property
-    @lru_cache(maxsize=1)
-    def type(self):
-        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)
-
-    @property
-    @lru_cache(maxsize=1)
-    def uuid(self) -> Optional[str]:
-        return self._data.get("uuid") if isinstance(self._data, dict) else None
-
-    @property
-    @lru_cache(maxsize=1)
-    def schema(self):
-        return self._portal.get_schema(self.type)
-
-    @property
-    @lru_cache(maxsize=1)
-    def identifying_properties(self) -> 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 []
-        identifying_properties = []
-        for identifying_property in schema_identifying_properties:
-            if identifying_property not in ["uuid", "identifier", "aliases"]:
-                if self._data.get(identifying_property):
-                    identifying_properties.append(identifying_property)
-        if self._data.get("identifier"):
-            identifying_properties.insert(0, "identifier")
-        if self._data.get("uuid"):
-            identifying_properties.insert(0, "uuid")
-        if "aliases" in schema_identifying_properties and self._data.get("aliases"):
-            identifying_properties.append("aliases")
-        return identifying_properties
-
-    @property
-    @lru_cache(maxsize=1)
-    def identifying_paths(self) -> 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 = []
-        for identifying_property in identifying_properties:
-            if (identifying_value := self._data.get(identifying_property)):
-                if identifying_property == "uuid":
-                    identifying_paths.append(f"/{self.type}/{identifying_value}")
-                    identifying_paths.append(f"/{identifying_value}")
-                # For now at least we include the path both with and without the schema type component,
-                # as for some identifying values, it works (only) with, and some, it works (only) without.
-                # For example: If we have FileSet with "accession", an identifying property, with value
-                # SMAFSFXF1RO4 then /SMAFSFXF1RO4 works but /FileSet/SMAFSFXF1RO4 does not; and
-                # conversely using "submitted_id", also an identifying property, with value
-                # UW_FILE-SET_COLO-829BL_HI-C_1 then /UW_FILE-SET_COLO-829BL_HI-C_1 does
-                # 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}")
-                        identifying_paths.append(f"/{identifying_value_item}")
-                else:
-                    identifying_paths.append(f"/{self.type}/{identifying_value}")
-                    identifying_paths.append(f"/{identifying_value}")
-        return identifying_paths
-
-    @property
-    @lru_cache(maxsize=1)
-    def identifying_path(self) -> Optional[str]:
-        if identifying_paths := self.identifying_paths:
-            return identifying_paths[0]
-
-    def lookup(self, include_identifying_path: bool = False,
-               raw: bool = False) -> Optional[Union[Tuple[PortalObject, str], PortalObject]]:
-        return self._lookup(raw=raw) if include_identifying_path else self._lookup(raw=raw)[0]
-
-    def lookup_identifying_path(self) -> Optional[str]:
-        return self._lookup()[1]
-
-    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
-        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
-        for differences detected linkTo reference values, we will actually check that the object which is being
-        referenced is different or the same, e.g. the file_format reference (linkTo) property value "fastq" looks
-        different from "eb417c0a-70dd-42e3-9841-ac7f1ee22962" but they (may) refer to the same object.
-        """
-        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