dcicutils 8.7.0.1b25__tar.gz → 8.7.0.1b27__tar.gz

{dcicutils-8.7.0.1b25 → dcicutils-8.7.0.1b27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcicutils
-Version: 8.7.0.1b25
+Version: 8.7.0.1b27
 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.1b27/dcicutils/portal_object_utils.py

@@ -0,0 +1,105 @@
+from dcicutils.schema_utils import get_identifying_properties
+from dcicutils.portal_utils import Portal
+from functools import lru_cache
+from typing import List, Optional, Tuple, Union
+
+
+class PortalObject:
+
+    def __init__(self, portal: Portal, portal_object: dict, portal_object_type: Optional[str] = None) -> None:
+        self._portal = portal
+        self._object = portal_object
+        self._type = portal_object_type if isinstance(portal_object_type, str) and portal_object_type else None
+
+    @property
+    @lru_cache(maxsize=1)
+    def schema(self):
+        return self._portal.get_schema(self.schema_type)
+
+    @property
+    @lru_cache(maxsize=1)
+    def schema_type(self):
+        return self._type or Portal.get_schema_type(self._object)
+
+    @property
+    @lru_cache(maxsize=1)
+    def schema_types(self):
+        return self._type or Portal.get_schema_types(self._object)
+
+    @property
+    @lru_cache(maxsize=1)
+    def schema_identifying_properties(self) -> list:
+        if not (schema := self.schema):
+            return []
+        return get_identifying_properties(schema)
+
+    @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.
+        """
+        identifying_properties = []
+        for identifying_property in self.schema_identifying_properties:
+            if identifying_property not in ["uuid", "identifier", "aliases"]:
+                if self._object.get(identifying_property):
+                    identifying_properties.append(identifying_property)
+        if self._object.get("identifier"):
+            identifying_properties.insert(0, "identifier")
+        if self._object.get("uuid"):
+            identifying_properties.insert(0, "uuid")
+        if "aliases" in self.schema_identifying_properties and self._object.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._object.get(identifying_property)):
+                if identifying_property == "uuid":
+                    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.schema_type}/{identifying_value_item}")
+                        identifying_paths.append(f"/{identifying_value_item}")
+                else:
+                    identifying_paths.append(f"/{self.schema_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) -> Optional[Union[Tuple[dict, str], dict]]:
+        return self._lookup() if include_identifying_path else self._lookup()[0]
+
+    def lookup_identifying_path(self) -> Optional[str]:
+        return self._lookup()[1]
+
+    def _lookup(self) -> Tuple[Optional[dict], Optional[str]]:
+        try:
+            for identifying_path in self.identifying_paths:
+                if (value := self._portal.get(identifying_path)) and (value.status_code == 200):
+                    return value.json(), identifying_path
+        except Exception:
+            pass
+        return None, self.identifying_path

{dcicutils-8.7.0.1b25 → dcicutils-8.7.0.1b27}/dcicutils/portal_utils.py

@@ -69,8 +69,8 @@ class Portal:
             self._keys_file = portal._keys_file
             self._env = portal._env
             self._server = portal._server
-            self._app = portal._app
             self._vapp = portal._vapp
+            self._app = portal._app
 
         def init_from_vapp(vapp: Union[TestApp, VirtualApp, PyramidRouter], unspecified: Optional[list] = []) -> None:
             init(unspecified=unspecified)
@@ -211,8 +211,9 @@ class Portal:
     def vapp(self) -> Optional[TestApp]:
         return self._vapp
 
-    def get(self, url: str, follow: bool = True, raise_for_status: bool = False, **kwargs) -> OptionalResponse:
-        url = self.url(url)
+    def get(self, url: str, follow: bool = True,
+            raw: bool = False, database: bool = False, raise_for_status: bool = False, **kwargs) -> OptionalResponse:
+        url = self.url(url, raw, database)
         if not self.vapp:
             response = requests.get(url, allow_redirects=follow, **self._kwargs(**kwargs))
         else:
@@ -254,8 +255,14 @@ class Portal:
             response.raise_for_status()
         return response
 
-    def get_metadata(self, object_id: str) -> Optional[dict]:
-        return get_metadata(obj_id=object_id, vapp=self.vapp, key=self.key)
+    def get_metadata(self, object_id: str, raw: bool = False, database: bool = False) -> Optional[dict]:
+        if isinstance(raw, bool) and raw:
+            add_on = "frame=raw" + ("&datastore=database" if isinstance(database, bool) and database else "")
+        elif database:
+            add_on = "datastore=database"
+        else:
+            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]:
         if self.key:
@@ -287,20 +294,20 @@ class Portal:
     def schema_name(name: str) -> str:
         return to_camel_case(name.replace(" ", "") if not name.endswith(".json") else name[:-5])
 
-    def is_schema_type(self, schema_name_or_object: Union[str, dict], target_schema_name: str,
+    def is_schema_type(self, schema_name_or_portal_object: Union[str, dict], target_schema_name: str,
                        _schemas_super_type_map: Optional[list] = None) -> bool:
         """
-        If the given (first) schema_name_or_object argument is a string then returns True iff the
-        given schema (type) name isa type of the given target schema (type) name, i.e. the given
+        If the given (first) schema_name_or_portal_object argument is a string then returns True iff
+        the given schema (type) name isa type of the given target schema (type) name, i.e. the given
         schema type is the given target schema type or has an ancestor which is that type.
-        If the given (first) schema_name_or_object argument is a dictionary then
+        If the given (first) schema_name_or_portal_object argument is a dictionary then
         returns True iff this object value isa type of the given target schema type.
         """
-        if isinstance(schema_name_or_object, dict):
-            return self.isinstance_schema(schema_name_or_object, target_schema_name)
-        elif not isinstance(schema_name_or_object, str) or not schema_name_or_object:
+        if isinstance(schema_name_or_portal_object, dict):
+            return self.isinstance_schema(schema_name_or_portal_object, target_schema_name)
+        elif not isinstance(schema_name_or_portal_object, str) or not schema_name_or_portal_object:
             return False
-        schema_name = self.schema_name(schema_name_or_object).lower()
+        schema_name = self.schema_name(schema_name_or_portal_object).lower()
         target_schema_name = self.schema_name(target_schema_name).lower()
         if schema_name == target_schema_name:
             return True
@@ -312,39 +319,42 @@ class Portal:
                             return True
         return False
 
-    def isinstance_schema(self, value: dict, target_schema_name: str) -> bool:
+    def isinstance_schema(self, portal_object: dict, target_schema_name: str) -> bool:
         """
         Returns True iff the given object isa type of the given schema type.
         """
-        if isinstance(value, dict):
-            if isinstance(value_types := value.get("@type"), str):
-                value_types = [value_types]
+        if value_types := self.get_schema_types(portal_object):
+            schemas_super_type_map = self.get_schemas_super_type_map()
+            for value_type in value_types:
+                if self.is_schema_type(value_type, target_schema_name, schemas_super_type_map):
+                    return True
+        return False
+
+    @staticmethod
+    def get_schema_types(portal_object: dict) -> Optional[List[str]]:
+        if isinstance(portal_object, dict):
+            if isinstance(value_types := portal_object.get("@type"), str):
+                value_types = [value_types] if value_types else []
             elif not isinstance(value_types, list):
                 value_types = []
-            if isinstance(data_type := value.get("data_type"), list):
+            if isinstance(data_type := portal_object.get("data_type"), list):
                 value_types.extend(data_type)
             elif isinstance(data_type, str):
                 value_types.append(data_type)
-            if value_types:
-                schemas_super_type_map = self.get_schemas_super_type_map()
-                for value_type in value_types:
-                    if self.is_schema_type(value_type, target_schema_name, schemas_super_type_map):
-                        return True
-        return False
+            return value_types if value_types else None
 
-    def get_schema_type(self, value: dict) -> Optional[str]:
-        value_type = value.get("@type", value.get("data_type")) if isinstance(value, dict) else None
-        if isinstance(value_type, list):
-            value_type = value_type[0] if value_type else None
-        return value_type
+    @staticmethod
+    def get_schema_type(portal_object: dict) -> Optional[str]:
+        if value_types := Portal.get_schema_types(portal_object):
+            return value_types[0]
 
     @lru_cache(maxsize=1)
     def get_schemas_super_type_map(self) -> dict:
         """
         Returns the "super type map" for all of the known schemas (via /profiles).
         This is a dictionary with property names which are all known schema type names which
-        have (one or more) sub-types, and the value each such property name is an array of
-        all of those sub-types (direct and all descendents), in breadth first order.
+        have (one or more) sub-types, and the value of each such property name is an array
+        of all of those sub-types (direct and all descendents), in breadth first order.
         """
         def list_breadth_first(super_type_map: dict, super_type_name: str) -> dict:
             result = []
@@ -371,14 +381,19 @@ class Portal:
             super_type_map_flattened[super_type_name] = list_breadth_first(super_type_map, super_type_name)
         return super_type_map_flattened
 
-    def url(self, url: str) -> str:
+    def url(self, url: str, raw: bool = False, database: bool = False) -> str:
         if not isinstance(url, str) or not url:
             return "/"
-        if (lowercase_url := url.lower()).startswith("http://") or lowercase_url.startswith("https://"):
+        elif (lowercase_url := url.lower()).startswith("http://") or lowercase_url.startswith("https://"):
             return url
-        if not (url := re.sub(r"/+", "/", url)).startswith("/"):
+        elif not (url := re.sub(r"/+", "/", url)).startswith("/"):
             url = "/"
-        return self.server + url if self.server else url
+        url = self.server + url if self.server else url
+        if isinstance(raw, bool) and raw:
+            url += ("&" if "?" in url else "?") + "frame=raw"
+        if isinstance(database, bool) and database:
+            url += ("&" if "?" in url else "?") + "datastore=database"
+        return url
 
     def _kwargs(self, **kwargs) -> dict:
         if "headers" in kwargs:

{dcicutils-8.7.0.1b25 → dcicutils-8.7.0.1b27}/dcicutils/structured_data.py

@@ -602,12 +602,22 @@ class Portal(PortalBase):
         resolved = []
         if self._ref_exists_single(type_name, value):
             resolved.append(type_name)
+            # 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?
+            # Getting multiple values because, for example, we find
+            # both this /Sample/UW_CELL-CULTURE-SAMPLE_COLO-829BL_HI-C_1
+            # and /CellSample/UW_CELL-CULTURE-SAMPLE_COLO-829BL_HI-C_1
+            # Why does that matter at all? Same thing.
+            return resolved
         # Check for the given ref in all sub-types of the given type.
         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)
+                        # 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:

{dcicutils-8.7.0.1b25 → dcicutils-8.7.0.1b27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.7.0.1b25"  # TODO: To become 8.7.1
+version = "8.7.0.1b27"  # 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"