dcicutils 8.8.1.1b26__tar.gz → 8.8.1.1b28__tar.gz

{dcicutils-8.8.1.1b26 → dcicutils-8.8.1.1b28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.8.1.1b26
+Version: 8.8.1.1b28
 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.8.1.1b26 → dcicutils-8.8.1.1b28}/dcicutils/portal_object_utils.py

@@ -195,7 +195,7 @@ class PortalObject:
                         # sure we check accession format (since it does not have a pattern).
                         if callable(ref_lookup_strategy):
                             lookup_options, ref_validator = ref_lookup_strategy(
-                                self.type, schema, identifying_value)
+                                self._portal, self.type, schema, identifying_value)
                             if callable(ref_validator):
                                 if ref_validator(schema, identifying_property, identifying_value) is False:
                                     continue

{dcicutils-8.8.1.1b26 → dcicutils-8.8.1.1b28}/dcicutils/structured_data.py

@@ -822,7 +822,7 @@ class Portal(PortalBase):
         if callable(ref_lookup_strategy):
             self._ref_lookup_strategy = ref_lookup_strategy
         else:
-            self._ref_lookup_strategy = lambda type_name, schema, value: (Portal.LOOKUP_DEFAULT, None)
+            self._ref_lookup_strategy = lambda portal, type_name, schema, value: (Portal.LOOKUP_DEFAULT, None)
         if ref_lookup_nocache is True:
             self.ref_lookup = self.ref_lookup_uncached
             self._ref_cache = None
@@ -860,10 +860,6 @@ class Portal(PortalBase):
     @lru_cache(maxsize=100)
     def get_schema(self, schema_name: str) -> Optional[dict]:
         return schemas.get(Schema.type_name(schema_name), None) if (schemas := self.get_schemas()) else None
-#       if schema_name == schema_name.upper() and (schema := schemas.get(schema_name.lower().title())):
-#           return schema
-#       if schema_name == schema_name.lower() and (schema := schemas.get(schema_name.title())):
-#           return schema
 
     @lru_cache(maxsize=1)
     def get_schemas(self) -> Optional[dict]:
@@ -892,7 +888,7 @@ class Portal(PortalBase):
             self._ref_total_count += 1
         # First make sure the given value can possibly be a reference to the given type.
         schema = self.get_schema(type_name)
-        ref_lookup_strategy, ref_validator = self._ref_lookup_strategy(type_name, schema, value)
+        ref_lookup_flags, ref_validator = self._ref_lookup_strategy(self, type_name, schema, value)
         if not self._is_valid_ref(type_name, value, ref_validator):
             if called_from_map_ref:
                 self._ref_invalid_identifying_property_count += 1
@@ -922,11 +918,11 @@ class Portal(PortalBase):
         # Get the lookup strategy; i.e. should do we lookup by root path, and if so, should
         # we do this first, and do we lookup by subtypes; by default we lookup by root path
         # but not first, and we also lookup by subtypes by default.
-        ref_lookup_strategy, _ = self._ref_lookup_strategy(type_name, self.get_schema(type_name), value)
-        is_ref_lookup_specified_type = StructuredDataSet._is_ref_lookup_specified_type(ref_lookup_strategy)
-        is_ref_lookup_root = StructuredDataSet._is_ref_lookup_root(ref_lookup_strategy)
-        is_ref_lookup_root_first = StructuredDataSet._is_ref_lookup_root_first(ref_lookup_strategy)
-        is_ref_lookup_subtypes = StructuredDataSet._is_ref_lookup_subtypes(ref_lookup_strategy)
+        ref_lookup_flags, _ = self._ref_lookup_strategy(self, type_name, self.get_schema(type_name), value)
+        is_ref_lookup_specified_type = StructuredDataSet._is_ref_lookup_specified_type(ref_lookup_flags)
+        is_ref_lookup_root = StructuredDataSet._is_ref_lookup_root(ref_lookup_flags)
+        is_ref_lookup_root_first = StructuredDataSet._is_ref_lookup_root_first(ref_lookup_flags)
+        is_ref_lookup_subtypes = StructuredDataSet._is_ref_lookup_subtypes(ref_lookup_flags)
         # First construct the list of lookup paths at which to look for the referenced item.
         lookup_paths = []
         if is_ref_lookup_root_first:
@@ -971,9 +967,9 @@ class Portal(PortalBase):
             if not type_name or not value:
                 return None  # Should not happen.
         # Note that root lookup not applicable here.
-        ref_lookup_strategy, ref_validator = (
-            self._ref_lookup_strategy(type_name, self.get_schema(type_name), value))
-        is_ref_lookup_subtypes = StructuredDataSet._is_ref_lookup_subtypes(ref_lookup_strategy)
+        ref_lookup_flags, ref_validator = (
+            self._ref_lookup_strategy(self, type_name, self.get_schema(type_name), value))
+        is_ref_lookup_subtypes = StructuredDataSet._is_ref_lookup_subtypes(ref_lookup_flags)
         subtype_names = self.get_schema_subtype_names(type_name) if is_ref_lookup_subtypes else []
         for type_name in [type_name] + subtype_names:
             is_resolved, resolved_item = self._ref_exists_single_internally(type_name, value)

dcicutils-8.8.1.1b28/dcicutils/submitr/ref_lookup_strategy.py

@@ -0,0 +1,67 @@
+import re
+from typing import Optional
+from dcicutils.structured_data import Portal
+
+
+def ref_lookup_strategy(portal: Portal, type_name: str, schema: dict, value: str) -> (int, Optional[str]):
+    #
+    # FYI: Note this situation WRT object lookups ...
+    #
+    # /{submitted_id}                # NOT FOUND
+    # /UnalignedReads/{submitted_id} # OK
+    # /SubmittedFile/{submitted_id}  # OK
+    # /File/{submitted_id}           # NOT FOUND
+    #
+    # /{accession}                   # OK
+    # /UnalignedReads/{accession}    # NOT FOUND
+    # /SubmittedFile/{accession}     # NOT FOUND
+    # /File/{accession}              # OK
+    #
+    def ref_validator(schema: Optional[dict],
+                      property_name: Optional[str], property_value: Optional[str]) -> Optional[bool]:
+        """
+        Returns False iff the type represented by the given schema, can NOT be referenced by
+        the given property name with the given property value, otherwise returns None.
+
+        For example, if the schema is for the UnalignedReads type and the property name
+        is accession, then we will return False iff the given property value is NOT a properly
+        formatted accession ID. Otherwise, we will return None, which indicates that the
+        caller (in dcicutils.structured_data.Portal.ref_exists) will continue executing
+        its default behavior, which is to check other ways in which the given type can NOT
+        be referenced by the given value, i.e. it checks other identifying properties for
+        the type and makes sure any patterns (e.g. for submitted_id or uuid) are ahered to.
+
+        The goal (in structured_data) being to detect if a type is being referenced in such
+        a way that cannot possibly be allowed, i.e. because none of its identifying types
+        are in the required form (if indeed there any requirements). Note that it is guaranteed
+        that the given property name is indeed an identifying property for the given type.
+        """
+        if property_format := schema.get("properties", {}).get(property_name, {}).get("format"):
+            if (property_format == "accession") and (property_name == "accession"):
+                if not _is_accession_id(property_value):
+                    return False
+        return None
+
+    DEFAULT_RESPONSE = (Portal.LOOKUP_DEFAULT, ref_validator)
+
+    if not value:
+        return DEFAULT_RESPONSE
+    if not schema:
+        if not isinstance(portal, Portal) or not (schema := portal.get_schema(type_name)):
+            return DEFAULT_RESPONSE
+    if schema_properties := schema.get("properties"):
+        if schema_properties.get("accession") and _is_accession_id(value):
+            # Case: lookup by accession (only by root).
+            return Portal.LOOKUP_ROOT, ref_validator
+        elif schema_property_info_submitted_id := schema_properties.get("submitted_id"):
+            if schema_property_pattern_submitted_id := schema_property_info_submitted_id.get("pattern"):
+                if re.match(schema_property_pattern_submitted_id, value):
+                    # Case: lookup by submitted_id (only by specified type).
+                    return Portal.LOOKUP_SPECIFIED_TYPE, ref_validator
+    return DEFAULT_RESPONSE
+
+
+# This is here for now because of problems with circular dependencies.
+# See: smaht-portal/.../schema_formats.py
+def _is_accession_id(value: str) -> bool:
+    return isinstance(value, str) and re.match(r"^SMA[1-9A-Z]{9}$", value) is not None

{dcicutils-8.8.1.1b26 → dcicutils-8.8.1.1b28}/pyproject.toml

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