dcicutils 8.7.0.1b26__tar.gz → 8.7.0.1b27__tar.gz

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

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

@@ -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,31 +319,34 @@ 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:
@@ -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.1b26 → dcicutils-8.7.0.1b27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dcicutils"
-version = "8.7.0.1b26"  # 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"