dcicutils 8.7.1.1b4__py3-none-any.whl → 8.7.1.1b6__py3-none-any.whl

dcicutils/data_readers.py

@@ -7,11 +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):
 
-    CELL_DELETION_VALUES = ["*delete*"]  # cell values(s) indicating property deletion
-    CELL_DELETION_SENTINEL = object()  # special cell deletion sentinel value
+    CELL_DELETION_SENTINEL = _CellDeletionSentinal()
 
     def __init__(self):
         self.header = None
@@ -51,7 +61,7 @@ class RowReader(abc.ABC):
     def cell_value(self, value: Optional[Any]) -> str:
         if value is None:
             return ""
-        elif (value := str(value).strip()) in RowReader.CELL_DELETION_VALUES:
+        elif (value := str(value).strip()) in _CELL_DELETION_VALUES:
             return RowReader.CELL_DELETION_SENTINEL
         else:
             return value

dcicutils/misc_utils.py

@@ -2,6 +2,7 @@
 This file contains functions that might be generally useful.
 """
 
+from collections import namedtuple
 import contextlib
 import datetime
 import functools
@@ -17,6 +18,7 @@ import re
 import rfc3986.validators
 import rfc3986.exceptions
 import time
+import uuid
 import warnings
 import webtest  # importing the library makes it easier to mock testing
 
@@ -1148,16 +1150,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):
@@ -1519,6 +1527,17 @@ def create_dict(**kwargs) -> dict:
     return result
 
 
+def create_readonly_object(**kwargs):
+    """
+    Returns a new/unique object instance with readonly properties equal to the give kwargs.
+    """
+    readonly_class_name = "readonlyclass_" + str(uuid.uuid4()).replace("-", "")
+    readonly_class_args = " ".join(kwargs.keys())
+    readonly_class = namedtuple(readonly_class_name, readonly_class_args)
+    readonly_object = readonly_class(**kwargs)
+    return readonly_object
+
+
 def is_c4_arn(arn: str) -> bool:
     """
     Returns True iff the given (presumed) AWS ARN string value looks like it

dcicutils/portal_object_utils.py

@@ -1,7 +1,9 @@
+from copy import deepcopy
 from functools import lru_cache
 import re
-from typing import Any, Callable, List, Optional, Tuple, Type, Union
+from typing import Any, List, Optional, Tuple, Type, Union
 from dcicutils.data_readers import RowReader
+from dcicutils.misc_utils import create_readonly_object
 from dcicutils.portal_utils import Portal
 from dcicutils.schema_utils import Schema
 
@@ -10,6 +12,8 @@ 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
@@ -19,6 +23,10 @@ class PortalObject:
     def data(self):
         return self._data
 
+    @property
+    def portal(self):
+        return self._portal
+
     @property
     @lru_cache(maxsize=1)
     def type(self):
@@ -39,6 +47,9 @@ class PortalObject:
     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]:
@@ -114,77 +125,124 @@ class PortalObject:
             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)
+    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, self.type)
 
     _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(value):
-                result[f"#{index}"] = item
-            return result
+    def _compare(a: Any, b: Any, value_type: str, _path: Optional[str] = None) -> dict:
+        def diff_creating(value: Any) -> object:  # noqa
+            nonlocal value_type
+            return create_readonly_object(value=value, type=value_type,
+                                          creating_value=True, updating_value=None, deleting_value=False)
+        def diff_updating(value: Any, updating_value: Any) -> object:  # noqa
+            nonlocal value_type
+            return create_readonly_object(value=value, type=value_type,
+                                          creating_value=False, updating_value=updating_value, deleting_value=False)
+        def diff_deleting(value: Any) -> object:  # noqa
+            nonlocal value_type
+            return create_readonly_object(value=value, type=value_type,
+                                          creating_value=False, updating_value=None, deleting_value=True)
         diffs = {}
-        for key in a:
-            path = key_to_path(key)
-            if key not in b:
-                if a[key] != RowReader.CELL_DELETION_SENTINEL:
-                    diffs[path] = {"value": a[key], "creating_value": True}
+        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] = diff_creating(a[key])
+                else:
+                    diffs.update(PortalObject._compare(a[key], b[key], type, _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] = diff_updating(a[index], b[index])
+                            else:
+                                diffs[path] = diff_creating(a[index])
+                        else:
+                            if index < len(b):
+                                diffs[path] = diff_deleting(b[index])
+                elif len(b) < index:
+                    diffs.update(PortalObject._compare(a[index], b[index], value_type, _path=path))
+                else:
+                    diffs[path] = diff_creating(a[index])
+        elif a != b:
+            if a == PortalObject._PROPERTY_DELETION_SENTINEL:
+                diffs[_path] = diff_deleting(b)
             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):
-                    # Note that lists will be compared in order, which means the when dealing with
-                    # insertions/deletions to/from the list, we my easily mistakenly regard elements
-                    # of the list to be different when they are really the same, since they occupy
-                    # different indices within the array. This is just a known restriction of this
-                    # comparison functionality; and perhaps actually technically correct, but probably
-                    # in practice, at the application/semantic level, we likely regard the order of
-                    # lists as unimportant, and with a little more work here we could try to detect
-                    # and exclude from the diffs for a list, those elements in the list which are
-                    # equal to each other but which reside at different indices with then two lists.
-                    diffs.update(PortalObject._compare(list_to_dictionary(a[key]),
-                                                       list_to_dictionary(b[key]), compare=compare, _path=path))
-                elif a[key] != b[key]:
-                    if a[key] == RowReader.CELL_DELETION_SENTINEL:
-                        diffs[path] = {"value": b[key], "deleting_value": True}
-                    elif not callable(compare) or not compare(path, a[key], b[key]):
-                        diffs[path] = {"value": a[key], "updating_value": b[key]}
+                diffs[_path] = diff_updating(a, 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.
+        Changes are made to this Portal object in place; use normalized_refs function to make a copy.
+        If there are no "refs" (None or empty) or if the speicified reference is not found in this
+        list then the references will be looked up via Portal calls (via Portal.get_metadata).
+        """
+        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/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,
@@ -66,10 +70,15 @@ class StructuredDataSet:
     def validate(self, force: bool = False) -> None:
         def data_without_deleted_properties(data: dict) -> dict:
             nonlocal self
-            if self._prune:
-                return {key: value for key, value in data.items() if value != RowReader.CELL_DELETION_SENTINEL}
-            else:
-                return {key: "" if value == RowReader.CELL_DELETION_SENTINEL else value for key, value in data.items()}
+            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
@@ -106,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]:
@@ -192,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:
@@ -356,17 +369,9 @@ class Schema:
     def validate(self, data: dict) -> List[str]:
         errors = []
         for error in SchemaValidator(self.data, format_checker=SchemaValidator.FORMAT_CHECKER).iter_errors(data):
-            errors.append(error.message)
+            errors.append(f"Validation error at '{error.json_path}': {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)
@@ -430,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)
 
@@ -624,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?
@@ -638,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.1b4.dist-info → dcicutils-8.7.1.1b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.7.1.1b4
+Version: 8.7.1.1b6
 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.1b4.dist-info → dcicutils-8.7.1.1b6.dist-info}/RECORD

@@ -9,7 +9,7 @@ dcicutils/common.py,sha256=YE8Mt5-vaZWWz4uaChSVhqGFbFtW5QKtnIyOr4zG4vM,3955
 dcicutils/contribution_scripts.py,sha256=0k5Gw1TumcD5SAcXVkDd6-yvuMEw-jUp5Kfb7FJH6XQ,2015
 dcicutils/contribution_utils.py,sha256=vYLS1JUB3sKd24BUxZ29qUBqYeQBLK9cwo8x3k64uPg,25653
 dcicutils/creds_utils.py,sha256=xrLekD49Ex0GOpL9n7LlJA4gvNcY7txTVFOSYD7LvEU,11113
-dcicutils/data_readers.py,sha256=02b_EnTHnRFpzqXzd847ArUGieL5PgXc6269L9xxF9w,5978
+dcicutils/data_readers.py,sha256=ooEoFkYDWJMPdvnpIb9-Wpacyx--XkB8_fwnbPYLJK4,6239
 dcicutils/data_utils.py,sha256=k2OxOlsx7AJ6jF-YNlMyGus_JqSUBe4_n1s65Mv1gQQ,3098
 dcicutils/deployment_utils.py,sha256=rcNUFMe_tsrG4CHEtgBe41cZx4Pk4JqISPsjrJRMoEs,68891
 dcicutils/diff_utils.py,sha256=sQx-yz56DHAcQWOChYbAG3clXu7TbiZKlw-GggeveO0,8118
@@ -41,10 +41,10 @@ dcicutils/license_policies/park-lab-gpl-pipeline.jsonc,sha256=vLZkwm3Js-kjV44nug
 dcicutils/license_policies/park-lab-pipeline.jsonc,sha256=9qlY0ASy3iUMQlr3gorVcXrSfRHnVGbLhkS427UaRy4,283
 dcicutils/license_utils.py,sha256=d1cq6iwv5Ju-VjdoINi6q7CPNNL7Oz6rcJdLMY38RX0,46978
 dcicutils/log_utils.py,sha256=7pWMc6vyrorUZQf-V-M3YC6zrPgNhuV_fzm9xqTPph0,10883
-dcicutils/misc_utils.py,sha256=bMRWWxdbhuF3PKdCZEH-H4U1ecgT3Nag3EL92D9XGoY,100973
+dcicutils/misc_utils.py,sha256=9JqdVjHLkZUDTryngF3Dbu0m7XcbitbR7izWnxUSWc4,101953
 dcicutils/obfuscation_utils.py,sha256=fo2jOmDRC6xWpYX49u80bVNisqRRoPskFNX3ymFAmjw,5963
 dcicutils/opensearch_utils.py,sha256=V2exmFYW8Xl2_pGFixF4I2Cc549Opwe4PhFi5twC0M8,1017
-dcicutils/portal_object_utils.py,sha256=zc0pEacq-J8D1QE7pH1xnHC50fF3_VQ7VSKySOvRr0c,10551
+dcicutils/portal_object_utils.py,sha256=Aa61u0o9OyWR7M26dGceMW9MSgDEZLqrwAkwu8FD228,12445
 dcicutils/portal_utils.py,sha256=8XVRCy882RrB8QT2gGvW36c4nT1RJCgUApt_wLP-EG8,26706
 dcicutils/project_utils.py,sha256=qPdCaFmWUVBJw4rw342iUytwdQC0P-XKpK4mhyIulMM,31250
 dcicutils/qa_checkers.py,sha256=cdXjeL0jCDFDLT8VR8Px78aS10hwNISOO5G_Zv2TZ6M,20534
@@ -59,15 +59,15 @@ dcicutils/secrets_utils.py,sha256=8dppXAsiHhJzI6NmOcvJV5ldvKkQZzh3Fl-cb8Wm7MI,19
 dcicutils/sheet_utils.py,sha256=VlmzteONW5VF_Q4vo0yA5vesz1ViUah1MZ_yA1rwZ0M,33629
 dcicutils/snapshot_utils.py,sha256=ymP7PXH6-yEiXAt75w0ldQFciGNqWBClNxC5gfX2FnY,22961
 dcicutils/ssl_certificate_utils.py,sha256=F0ifz_wnRRN9dfrfsz7aCp4UDLgHEY8LaK7PjnNvrAQ,9707
-dcicutils/structured_data.py,sha256=ljXvLy1yUcrAvguAlbAfQ_mqHILw84HEQ1_NcMnXBRk,34659
+dcicutils/structured_data.py,sha256=voFT8RqVXLX6-sZiEfhsgmwXEiMcJUrHneYUDXNm9wk,35647
 dcicutils/task_utils.py,sha256=MF8ujmTD6-O2AC2gRGPHyGdUrVKgtr8epT5XU8WtNjk,8082
 dcicutils/tmpfile_utils.py,sha256=n95XF8dZVbQRSXBZTGToXXfSs3JUVRyN6c3ZZ0nhAWI,1403
 dcicutils/trace_utils.py,sha256=g8kwV4ebEy5kXW6oOrEAUsurBcCROvwtZqz9fczsGRE,1769
 dcicutils/validation_utils.py,sha256=cMZIU2cY98FYtzK52z5WUYck7urH6JcqOuz9jkXpqzg,14797
 dcicutils/variant_utils.py,sha256=2H9azNx3xAj-MySg-uZ2SFqbWs4kZvf61JnK6b-h4Qw,4343
 dcicutils/zip_utils.py,sha256=rnjNv_k6L9jT2SjDSgVXp4BEJYLtz9XN6Cl2Fy-tqnM,2027
-dcicutils-8.7.1.1b4.dist-info/LICENSE.txt,sha256=qnwSmfnEWMl5l78VPDEzAmEbLVrRqQvfUQiHT0ehrOo,1102
-dcicutils-8.7.1.1b4.dist-info/METADATA,sha256=tdGvBos2PdrsL-KAOgu_qcVDh_4j8AcUdXpsxrEEWDU,3314
-dcicutils-8.7.1.1b4.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-dcicutils-8.7.1.1b4.dist-info/entry_points.txt,sha256=8wbw5csMIgBXhkwfgsgJeuFcoUc0WsucUxmOyml2aoA,209
-dcicutils-8.7.1.1b4.dist-info/RECORD,,
+dcicutils-8.7.1.1b6.dist-info/LICENSE.txt,sha256=qnwSmfnEWMl5l78VPDEzAmEbLVrRqQvfUQiHT0ehrOo,1102
+dcicutils-8.7.1.1b6.dist-info/METADATA,sha256=YLm-JVegaODLOnyLLQgUzFTwUPRlK-9dn0eZP1ANmHY,3314
+dcicutils-8.7.1.1b6.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+dcicutils-8.7.1.1b6.dist-info/entry_points.txt,sha256=8wbw5csMIgBXhkwfgsgJeuFcoUc0WsucUxmOyml2aoA,209
+dcicutils-8.7.1.1b6.dist-info/RECORD,,