fmu-sumo 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

fmu/sumo/explorer/objects/case.py

@@ -4,11 +4,11 @@ from typing import Dict
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._document import Document
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._document import Document
+from ._search_context import SearchContext
 
 
-def _make_overview_query(id):
+def _make_overview_query(id) -> Dict:
     return {
         "query": {"term": {"fmu.case.uuid.keyword": id}},
         "aggs": {
@@ -52,7 +52,7 @@ class Case(Document, SearchContext):
         self._iterations = None
 
     @property
-    def overview(self):
+    def overview(self) -> Dict:
         """Overview of case contents."""
 
         def extract_bucket_keys(bucket, name):

fmu/sumo/explorer/objects/cases.py

@@ -1,6 +1,6 @@
 """Module for searchcontext for collection of cases."""
 
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._search_context import SearchContext
 
 
 class Cases(SearchContext):
@@ -16,6 +16,8 @@ class Cases(SearchContext):
         return
 
     def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.uuids
-        return Cases(self, uuids)
+        sc = SearchContext(
+            self._sumo, must=[{"terms": {"fmu.case.uuid.keyword": self._hits}}]
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.case.uuid.keyword")
+        return Cases(sc, uuids)

fmu/sumo/explorer/objects/cpgrid.py

@@ -4,8 +4,8 @@ from typing import Dict
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._child import Child
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._child import Child
+from ._search_context import SearchContext
 
 
 class CPGrid(Child):
@@ -32,7 +32,7 @@ class CPGrid(Child):
                 "Unable to import xtgeo; probably not installed."
             )
         try:
-            return grid_from_file(self.blob)
+            return grid_from_file(self.blob)  # pyright: ignore type
         except TypeError as type_err:
             raise TypeError(f"Unknown format: {self.format}") from type_err
 
@@ -49,7 +49,7 @@ class CPGrid(Child):
             )
 
         try:
-            return grid_from_file(await self.blob_async)
+            return grid_from_file(await self.blob_async)  # pyright: ignore type
         except TypeError as type_err:
             raise TypeError(f"Unknown format: {self.format}") from type_err
 

fmu/sumo/explorer/objects/cpgrid_property.py

@@ -4,8 +4,8 @@ from typing import Dict
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._child import Child
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._child import Child
+from ._search_context import SearchContext
 
 
 class CPGridProperty(Child):

fmu/sumo/explorer/objects/cube.py

@@ -1,10 +1,10 @@
 """Module containing class for cube object"""
 
-from typing import Dict
+from typing import Dict, Tuple
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._child import Child
+from ._child import Child
 
 
 class Cube(Child):
@@ -17,64 +17,28 @@ class Cube(Child):
             metadata (dict): cube metadata
         """
         super().__init__(sumo, metadata, blob)
-        self._url = None
-        self._sas = None
 
-    def _populate_url(self):
-        res = self._sumo.get(f"/objects('{self.uuid}')/blob/authuri")
+    def _extract_auth(self, res) -> Tuple[str, str]:
         try:
             res = res.json()
-            self._url = res.get("baseuri") + self.uuid
-            self._sas = res.get("auth")
+            url = res.get("baseuri") + self.uuid
+            sas = res.get("auth")
         except Exception:
-            self._url = res.text
-
-    async def _populate_url_async(self):
-        res = await self._sumo.get_async(
-            f"/objects('{self.uuid}')/blob/authuri"
-        )
-        try:
-            res = res.json()
-            self._url = res.get("baseuri") + self.uuid
-            self._sas = res.get("auth")
-        except Exception:
-            self._url = res.text
-
-    @property
-    def url(self) -> str:
-        if self._url is None:
-            self._populate_url()
-        if self._sas is None:
-            return self._url
-        else:
-            return self._url.split("?")[0] + "/"
-
-    @property
-    async def url_async(self) -> str:
-        if self._url is None:
-            await self._populate_url_async()
-        if self._sas is None:
-            return self._url
-        else:
-            return self._url.split("?")[0] + "/"
+            url, sas = res.text.split("?")
+            pass
+        return url, sas
 
     @property
-    def sas(self) -> str:
-        if self._url is None:
-            self._populate_url()
-        if self._sas is None:
-            return self._url.split("?")[1]
-        else:
-            return self._sas
+    def auth(self) -> Tuple[str, str]:
+        res = self._sumo.get(f"/objects('{self.uuid}')/blob/authuri")
+        return self._extract_auth(res)
 
     @property
-    async def sas_async(self) -> str:
-        if self._url is None:
-            await self._populate_url_async()
-        if self._sas is None:
-            return self._url.split("?")[1]
-        else:
-            return self._sas
+    async def auth_async(self) -> Tuple[str, str]:
+        res = await self._sumo.get_async(
+            f"/objects('{self.uuid}')/blob/authuri"
+        )
+        return self._extract_auth(res)
 
     @property
     def openvds_handle(self):
@@ -85,15 +49,10 @@ class Cube(Child):
                 "Unable to import openvds; probably not installed."
             )
 
-        if self._url is None:
-            self._populate_url()
-
-        if self._sas is None:
-            return openvds.open(self._url)
-        else:
-            url = "azureSAS" + self._url[5:] + "/"
-            sas = "Suffix=?" + self._sas
-            return openvds.open(url, sas)
+        url, sas = self.auth
+        url = url.replace("https://", "azureSAS://") + "/"
+        sas = "Suffix=?" + sas
+        return openvds.open(url, sas)
 
     @property
     async def openvds_handle_async(self):
@@ -104,12 +63,7 @@ class Cube(Child):
                 "Unable to import openvds; probably not installed."
             )
 
-        if self._url is None:
-            await self._populate_url_async()
-
-        if self._sas is None:
-            return openvds.open(self._url)
-        else:
-            url = "azureSAS" + self._url[5:] + "/"
-            sas = "Suffix=?" + self._sas
-            return openvds.open(url, sas)
+        url, sas = await self.auth_async
+        url = url.replace("https://", "azureSAS://") + "/"
+        sas = "Suffix=?" + sas
+        return openvds.open(url, sas)

fmu/sumo/explorer/objects/dictionary.py

@@ -1,7 +1,7 @@
 """Module containing class for dictionary object"""
 
 import json
-from typing import Dict
+from typing import Dict, Optional
 
 from sumo.wrapper import SumoClient
 
@@ -11,7 +11,7 @@ from fmu.sumo.explorer.objects._child import Child
 class Dictionary(Child):
     """Class representing a dictionary object in Sumo"""
 
-    _parsed: dict
+    _parsed: Optional[Dict]
 
     def __init__(self, sumo: SumoClient, metadata: Dict, blob=None) -> None:
         """
@@ -19,18 +19,26 @@ class Dictionary(Child):
             sumo (SumoClient): connection to Sumo
             metadata (dict): dictionary metadata
         """
-        self._parsed = None
+        self._parsed: Optional[Dict] = None
 
         super().__init__(sumo, metadata, blob)
 
     def parse(self) -> Dict:
+        parsed = (
+            json.loads(self.blob.read().decode("utf-8"))
+            if self._parsed is None
+            else self._parsed
+        )
         if self._parsed is None:
-            self._parsed = json.loads(self.blob.read().decode("utf-8"))
-
-        return self._parsed
+            self._parsed = parsed
+        return parsed
 
     async def parse_async(self) -> Dict:
+        parsed = self._parsed = (
+            json.loads((await self.blob_async).read().decode("utf-8"))
+            if self._parsed is None
+            else self._parsed
+        )
         if self._parsed is None:
-            self._parsed = json.loads(self.blob_async.read().decode("utf-8"))
-
-        return self._parsed
+            self._parsed = parsed
+        return parsed

fmu/sumo/explorer/objects/ensemble.py

@@ -0,0 +1,76 @@
+"""Module for (pseudo) ensemble class."""
+
+from typing import Dict, Optional
+
+from sumo.wrapper import SumoClient
+
+from ._document import Document
+from ._search_context import SearchContext
+
+
+class Ensemble(Document, SearchContext):
+    """Class for representing an ensemble in Sumo."""
+
+    def __init__(
+        self, sumo: SumoClient, metadata: Dict, blob: Optional[bytes] = None
+    ):
+        assert blob is None
+        Document.__init__(self, metadata)
+        SearchContext.__init__(
+            self,
+            sumo,
+            must=[{"term": {"fmu.ensemble.uuid.keyword": self.uuid}}],
+        )
+        pass
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+            f"in case {self.casename} "
+            f"in asset {self.asset}>"
+        )
+
+    @property
+    def field(self) -> str:
+        """Case field"""
+        return self.get_property("masterdata.smda.field[0].identifier")
+
+    @property
+    def asset(self) -> str:
+        """Case asset"""
+        return self.get_property("access.asset.name")
+
+    @property
+    def user(self) -> str:
+        """Name of user who uploaded ensemble."""
+        return self.get_property("fmu.case.user.id")
+
+    @property
+    def caseuuid(self) -> str:
+        """FMU case uuid"""
+        return self.get_property("fmu.case.uuid")
+
+    @property
+    def casename(self) -> str:
+        """FMU case name"""
+        return self.get_property("fmu.case.name")
+
+    @property
+    def ensembleuuid(self) -> str:
+        """FMU ensemble uuid"""
+        return self.get_property("fmu.ensemble.uuid")
+
+    @property
+    def ensemblename(self) -> str:
+        """FMU ensemble name"""
+        return self.get_property("fmu.ensemble.name")
+
+    @property
+    def name(self) -> str:
+        """FMU ensemble name"""
+        return self.get_property("fmu.ensemble.name")
+
+    @property
+    def uuid(self) -> str:
+        """FMU ensemble uuid"""
+        return self.get_property("fmu.ensemble.uuid")

fmu/sumo/explorer/objects/ensembles.py

@@ -0,0 +1,81 @@
+"""Module for searchcontext for collection of ensembles."""
+
+from typing import Dict, List
+
+from ._search_context import SearchContext
+
+
+class Ensembles(SearchContext):
+    def __init__(self, sc, uuids):
+        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
+        self._hits = uuids
+        return
+
+    # def __str__(self) -> str:
+    #     length = len(self)
+    #     if length == 0:
+    #         return "None"
+    #     else:
+    #         preview = [self[i].metadata for i in range(min(5, length))]
+    #         return f"Data Preview:\n{json.dumps(preview, indent=4)}"
+
+    # def __repr__(self) -> str:
+    #     return(f"<{self.__class__.__name__} {len(self)} objects of type ensemble>")
+
+    @property
+    def classes(self) -> List[str]:
+        return ["ensemble"]
+
+    @property
+    async def classes_async(self) -> List[str]:
+        return ["ensemble"]
+
+    def _maybe_prefetch(self, index):
+        return
+
+    async def _maybe_prefetch_async(self, index):
+        return
+
+    def get_object(self, uuid: str) -> Dict:
+        """Get metadata object by uuid
+
+        Args:
+            uuid (str): uuid of metadata object
+            select (List[str]): list of metadata fields to return
+
+        Returns:
+            Dict: a metadata object
+        """
+        obj = self._cache.get(uuid)
+        if obj is None:
+            obj = self.get_ensemble_by_uuid(uuid)
+            self._cache.put(uuid, obj)
+            pass
+
+        return obj
+
+    async def get_object_async(self, uuid: str) -> Dict:
+        """Get metadata object by uuid
+
+        Args:
+            uuid (str): uuid of metadata object
+            select (List[str]): list of metadata fields to return
+
+        Returns:
+            Dict: a metadata object
+        """
+
+        obj = self._cache.get(uuid)
+        if obj is None:
+            obj = await self.get_ensemble_by_uuid_async(uuid)
+            self._cache.put(uuid, obj)
+
+        return obj
+
+    def filter(self, **kwargs):
+        sc = SearchContext(
+            self._sumo,
+            must=[{"terms": {"fmu.ensemble.uuid.keyword": self._hits}}],
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.iteration.uuid.keyword")
+        return Ensembles(sc, uuids)

fmu/sumo/explorer/objects/iteration.py

@@ -1,17 +1,20 @@
 """Module for (pseudo) iteration class."""
 
-from typing import Dict
+from typing import Dict, Optional
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._document import Document
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._document import Document
+from ._search_context import SearchContext
 
 
 class Iteration(Document, SearchContext):
     """Class for representing an iteration in Sumo."""
 
-    def __init__(self, sumo: SumoClient, metadata: Dict):
+    def __init__(
+        self, sumo: SumoClient, metadata: Dict, blob: Optional[bytes] = None
+    ):
+        assert blob is None
         Document.__init__(self, metadata)
         SearchContext.__init__(
             self,
@@ -20,6 +23,13 @@ class Iteration(Document, SearchContext):
         )
         pass
 
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+            f"in case {self.casename} "
+            f"in asset {self.asset}>"
+        )
+
     @property
     def field(self) -> str:
         """Case field"""
@@ -45,7 +55,22 @@ class Iteration(Document, SearchContext):
         """FMU case name"""
         return self.get_property("fmu.case.name")
 
+    @property
+    def iterationuuid(self) -> str:
+        """FMU iteration uuid"""
+        return self.get_property("fmu.iteration.uuid")
+
+    @property
+    def iterationname(self) -> str:
+        """FMU iteration name"""
+        return self.get_property("fmu.iteration.name")
+
     @property
     def name(self) -> str:
         """FMU iteration name"""
         return self.get_property("fmu.iteration.name")
+
+    @property
+    def uuid(self) -> str:
+        """FMU iteration uuid"""
+        return self.get_property("fmu.iteration.uuid")

fmu/sumo/explorer/objects/iterations.py

@@ -2,7 +2,7 @@
 
 from typing import Dict, List
 
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._search_context import SearchContext
 
 
 class Iterations(SearchContext):
@@ -11,13 +11,21 @@ class Iterations(SearchContext):
         self._hits = uuids
         return
 
+    @property
+    def classes(self) -> List[str]:
+        return ["iteration"]
+
+    @property
+    async def classes_async(self) -> List[str]:
+        return ["iteration"]
+
     def _maybe_prefetch(self, index):
         return
 
     async def _maybe_prefetch_async(self, index):
         return
 
-    def get_object(self, uuid: str, select: List[str] = None) -> Dict:
+    def get_object(self, uuid: str) -> Dict:
         """Get metadata object by uuid
 
         Args:
@@ -35,9 +43,7 @@ class Iterations(SearchContext):
 
         return obj
 
-    async def get_object_async(
-        self, uuid: str, select: List[str] = None
-    ) -> Dict:
+    async def get_object_async(self, uuid: str) -> Dict:
         """Get metadata object by uuid
 
         Args:
@@ -56,6 +62,9 @@ class Iterations(SearchContext):
         return obj
 
     def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.uuids
-        return Iterations(self, uuids)
+        sc = SearchContext(
+            self._sumo,
+            must=[{"terms": {"fmu.iteration.uuid.keyword": self._hits}}],
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.iteration.uuid.keyword")
+        return Iterations(sc, uuids)

fmu/sumo/explorer/objects/polygons.py

@@ -4,7 +4,7 @@ from typing import Dict
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._child import Child
+from ._child import Child
 
 
 class Polygons(Child):

fmu/sumo/explorer/objects/realization.py

@@ -1,17 +1,20 @@
 """Module for (pseudo) realization class."""
 
-from typing import Dict
+from typing import Dict, Optional
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._document import Document
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._document import Document
+from ._search_context import SearchContext
 
 
 class Realization(Document, SearchContext):
     """Class for representing a realization in Sumo."""
 
-    def __init__(self, sumo: SumoClient, metadata: Dict):
+    def __init__(
+        self, sumo: SumoClient, metadata: Dict, blob: Optional[bytes] = None
+    ):
+        assert blob is None
         Document.__init__(self, metadata)
         SearchContext.__init__(
             self,
@@ -20,6 +23,14 @@ class Realization(Document, SearchContext):
         )
         pass
 
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}: {self.realizationid} {self.uuid}(uuid) "
+            f"in iteration {self.iterationname} "
+            f"in case {self.casename} "
+            f"in asset {self.asset}>"
+        )
+
     @property
     def field(self) -> str:
         """Case field"""
@@ -54,3 +65,18 @@ class Realization(Document, SearchContext):
     def iterationname(self) -> str:
         """FMU iteration name"""
         return self.get_property("fmu.iteration.name")
+
+    @property
+    def realizationuuid(self) -> str:
+        """FMU realization uuid"""
+        return self.get_property("fmu.realization.uuid")
+
+    @property
+    def realizationname(self) -> str:
+        """FMU realization name"""
+        return self.get_property("fmu.realization.name")
+
+    @property
+    def realizationid(self) -> int:
+        """FMU realization id"""
+        return self.get_property("fmu.realization.id")

fmu/sumo/explorer/objects/realizations.py

@@ -1,8 +1,8 @@
 """Module for searchcontext for collection of realizations."""
 
-from typing import Dict, List
+from typing import Dict
 
-from fmu.sumo.explorer.objects._search_context import SearchContext
+from ._search_context import SearchContext
 
 
 class Realizations(SearchContext):
@@ -17,7 +17,7 @@ class Realizations(SearchContext):
     async def _maybe_prefetch_async(self, index):
         return
 
-    def get_object(self, uuid: str, select: List[str] = None) -> Dict:
+    def get_object(self, uuid: str) -> Dict:
         """Get metadata object by uuid
 
         Args:
@@ -35,9 +35,7 @@ class Realizations(SearchContext):
 
         return obj
 
-    async def get_object_async(
-        self, uuid: str, select: List[str] = None
-    ) -> Dict:
+    async def get_object_async(self, uuid: str) -> Dict:
         """Get metadata object by uuid
 
         Args:
@@ -56,6 +54,9 @@ class Realizations(SearchContext):
         return obj
 
     def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.uuids
+        sc = SearchContext(
+            self._sumo,
+            must=[{"terms": {"fmu.realization.uuid.keyword": self._hits}}],
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.realization.uuid.keyword")
         return Realizations(self, uuids)

fmu/sumo/explorer/objects/surface.py

@@ -4,7 +4,7 @@ from typing import Dict
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._child import Child
+from ._child import Child
 
 
 class Surface(Child):

fmu/sumo/explorer/objects/table.py

@@ -5,7 +5,7 @@ from typing import Dict
 
 from sumo.wrapper import SumoClient
 
-from fmu.sumo.explorer.objects._child import Child
+from ._child import Child
 
 
 class Table(Child):