fmu-sumo 2.8.1__tar.gz → 2.9.0__tar.gz

{fmu_sumo-2.8.1/src/fmu_sumo.egg-info → fmu_sumo-2.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-sumo
-Version: 2.8.1
+Version: 2.9.0
 Summary: Python package for interacting with Sumo in an FMU setting
 Author: Equinor
 License:                                  Apache License

{fmu_sumo-2.8.1 → fmu_sumo-2.9.0}/src/fmu/sumo/explorer/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.8.1'
-__version_tuple__ = version_tuple = (2, 8, 1)
+__version__ = version = '2.9.0'
+__version_tuple__ = version_tuple = (2, 9, 0)
 
-__commit_id__ = commit_id = 'g085fb1035'
+__commit_id__ = commit_id = 'gbcff66149'

{fmu_sumo-2.8.1 → fmu_sumo-2.9.0}/src/fmu/sumo/explorer/objects/__init__.py

@@ -12,8 +12,6 @@ from .cube import Cube
 from .dictionary import Dictionary
 from .ensemble import Ensemble
 from .ensembles import Ensembles
-from .iteration import Iteration
-from .iterations import Iterations
 from .polygons import Polygons
 from .realization import Realization
 from .realizations import Realizations

{fmu_sumo-2.8.1 → fmu_sumo-2.9.0}/src/fmu/sumo/explorer/objects/_search_context.py

@@ -368,7 +368,6 @@ class SearchContext:
             "table": objects.Table,
             "cpgrid": objects.CPGrid,
             "cpgrid_property": objects.CPGridProperty,
-            "iteration": objects.Iteration,  # FIXME: to be removed
             "ensemble": objects.Ensemble,
             "realization": objects.Realization,
         }.get(cls)
@@ -481,16 +480,22 @@ class SearchContext:
             query=self._query, size=1000, select=select
         )
 
+    def _getuuids(self):
+        return self._search_all()
+
+    async def _getuuids_async(self):
+        return await self._search_all_async()
+
     @property
     def uuids(self):
         if self._hits is None:
-            self._hits = self._search_all()
+            self._hits = self._getuuids()
         return self._hits
 
     @property
     async def uuids_async(self):
         if self._hits is None:
-            self._hits = await self._search_all_async()
+            self._hits = await self._getuuids_async()
         return self._hits
 
     def __iter__(self):
@@ -527,15 +532,17 @@ class SearchContext:
 
     def __getitem__(self, index):
         if self._hits is None:
-            self._hits = self._search_all()
+            self._hits = self._getuuids()
             pass
+        self._maybe_prefetch(index)
         uuid = self._hits[index]
         return self.get_object(uuid)
 
     async def getitem_async(self, index):
         if self._hits is None:
-            self._hits = await self._search_all_async()
+            self._hits = await self._getuuids_async()
             pass
+        await self._maybe_prefetch_async(index)
         uuid = self._hits[index]
         return await self.get_object_async(uuid)
 
@@ -599,66 +606,6 @@ class SearchContext:
         self._cache.clear()
         return self
 
-    def _ensemble_or_realization_query(self, uuid: str) -> dict:
-        return {
-            "query": {
-                "bool": {
-                    "minimum_should_match": 1,
-                    "should": [
-                        {"term": {"fmu.ensemble.uuid.keyword": uuid}},
-                        {"term": {"fmu.iteration.uuid.keyword": uuid}},
-                        {"term": {"fmu.realization.uuid.keyword": uuid}},
-                    ],
-                }
-            },
-            "size": 1,
-            "_source": {
-                "includes": [
-                    "$schema",
-                    "class",
-                    "source",
-                    "version",
-                    "access",
-                    "masterdata",
-                    "fmu.case",
-                    "fmu.iteration",
-                    "fmu.ensemble",
-                    "fmu.realization",
-                ],
-            },
-        }
-
-    def _patch_ensemble_or_realization(self, uuid, hits):
-        if len(hits) == 1:
-            obj = hits[0]["_source"]
-            if obj["fmu"]["ensemble"]["uuid"] == uuid:
-                obj["class"] = "ensemble"
-            elif obj["fmu"]["iteration"]["uuid"] == uuid:
-                obj["class"] = "iteration"
-            elif obj["fmu"]["realization"]["uuid"] == uuid:
-                obj["class"] = "realization"
-            if (
-                obj["class"] in ["iteration", "ensemble"]
-                and "realization" in obj["fmu"]
-            ):
-                del obj["fmu"]["realization"]
-
-    def _get_ensemble_or_realization(self, uuid: str) -> List[Dict]:
-        query = self._ensemble_or_realization_query(uuid)
-        res = self._sumo.post("/search", json=query)
-        hits = res.json()["hits"]["hits"]
-        self._patch_ensemble_or_realization(uuid, hits)
-        return hits
-
-    async def _get_ensemble_or_realization_async(
-        self, uuid: str
-    ) -> List[Dict]:
-        query = self._ensemble_or_realization_query(uuid)
-        res = await self._sumo.post_async("/search", json=query)
-        hits = res.json()["hits"]["hits"]
-        self._patch_ensemble_or_realization(uuid, hits)
-        return hits
-
     def get_object(self, uuid: str) -> objects.Document:
         """Get metadata object by uuid
 
@@ -679,12 +626,6 @@ class SearchContext:
 
             res = self._sumo.post("/search", json=query)
             hits = res.json()["hits"]["hits"]
-
-            if len(hits) == 0:
-                hits = self._get_ensemble_or_realization(uuid)
-                if len(hits) == 0:
-                    raise Exception(f"Document not found: {uuid}")
-                pass
             obj = hits[0]
             self._cache.put(uuid, obj)
 
@@ -712,11 +653,6 @@ class SearchContext:
             res = await self._sumo.post_async("/search", json=query)
             hits = res.json()["hits"]["hits"]
 
-            if len(hits) == 0:
-                hits = await self._get_ensemble_or_realization_async(uuid)
-                if len(hits) == 0:
-                    raise Exception(f"Document not found: {uuid}")
-                pass
             obj = hits[0]
             self._cache.put(uuid, obj)
 
@@ -1142,22 +1078,6 @@ class SearchContext:
         uuids = await self.get_field_values_async("fmu.case.uuid.keyword")
         return objects.Cases(self, uuids)
 
-    @property
-    @deprecation.deprecated(details="Use the method 'ensembles' instead.")
-    def iterations(self):
-        """Iterations from current selection."""
-        uuids = self.get_field_values("fmu.iteration.uuid.keyword")
-        return objects.Iterations(self, uuids)
-
-    @property
-    @deprecation.deprecated(
-        details="Use the method 'ensembles_async' instead."
-    )
-    async def iterations_async(self):
-        """Iterations from current selection."""
-        uuids = await self.get_field_values_async("fmu.iteration.uuid.keyword")
-        return objects.Iterations(self, uuids)
-
     @property
     def ensembles(self):
         """Ensembles from current selection."""
@@ -1424,32 +1344,6 @@ class SearchContext:
         """
         return await self._get_object_by_class_and_uuid_async("case", uuid)
 
-    def get_iteration_by_uuid(self, uuid: str) -> objects.Iteration:
-        """Get iteration object by uuid
-
-        Args:
-            uuid (str): iteration uuid
-
-        Returns: iteration object
-        """
-        obj = self.get_object(uuid)
-        assert isinstance(obj, objects.Iteration)
-        return obj
-
-    async def get_iteration_by_uuid_async(
-        self, uuid: str
-    ) -> objects.Iteration:
-        """Get iteration object by uuid
-
-        Args:
-            uuid (str): iteration uuid
-
-        Returns: iteration object
-        """
-        obj = await self.get_object_async(uuid)
-        assert isinstance(obj, objects.Iteration)
-        return obj
-
     def get_ensemble_by_uuid(self, uuid: str) -> objects.Ensemble:
         """Get ensemble object by uuid
 

{fmu_sumo-2.8.1 → fmu_sumo-2.9.0}/src/fmu/sumo/explorer/objects/cases.py

@@ -1,5 +1,7 @@
 """Module for searchcontext for collection of cases."""
 
+from typing import List
+
 from ._search_context import SearchContext
 
 
@@ -9,16 +11,19 @@ class Cases(SearchContext):
         self._hits = uuids
         return
 
-    def _maybe_prefetch(self, index):
-        return
+    def __len__(self):
+        return len(self.uuids)
 
-    async def _maybe_prefetch_async(self, index):
-        return
+    async def length_async(self):
+        return len(await self.uuids_async)
 
-    def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.get_field_values("fmu.case.uuid.keyword")
-        return Cases(sc, uuids)
+    @property
+    def classes(self) -> List[str]:
+        return ["case"]
+
+    @property
+    async def classes_async(self) -> List[str]:
+        return ["case"]
 
     @property
     def names(self):

fmu_sumo-2.9.0/src/fmu/sumo/explorer/objects/ensembles.py

@@ -0,0 +1,34 @@
+"""Module for searchcontext for collection of ensembles."""
+
+from typing import 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 __len__(self):
+        return len(self.uuids)
+
+    async def length_async(self):
+        return len(await self.uuids_async)
+
+    @property
+    def classes(self) -> List[str]:
+        return ["ensemble"]
+
+    @property
+    async def classes_async(self) -> List[str]:
+        return ["ensemble"]
+
+    @property
+    def ensemblenames(self) -> List[str]:
+        return self.get_field_values("fmu.ensemble.name.keyword")
+
+    @property
+    async def ensemblenames_async(self) -> List[str]:
+        return await self.get_field_values_async("fmu.ensemble.name.keyword")

fmu_sumo-2.9.0/src/fmu/sumo/explorer/objects/realizations.py

@@ -0,0 +1,34 @@
+"""Module for searchcontext for collection of realizations."""
+
+from typing import List
+
+from ._search_context import SearchContext
+
+
+class Realizations(SearchContext):
+    def __init__(self, sc, uuids):
+        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
+        self._hits = uuids
+        return
+
+    def __len__(self):
+        return len(self.uuids)
+
+    async def length_async(self):
+        return len(await self.uuids_async)
+
+    @property
+    def classes(self) -> List[str]:
+        return ["realization"]
+
+    @property
+    async def classes_async(self) -> List[str]:
+        return ["realization"]
+
+    @property
+    def realizationids(self) -> List[int]:
+        return self.get_field_values("fmu.realization.id")
+
+    @property
+    async def realizationids_async(self) -> List[int]:
+        return await self.get_field_values_async("fmu.realization.id")

{fmu_sumo-2.8.1 → fmu_sumo-2.9.0/src/fmu_sumo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-sumo
-Version: 2.8.1
+Version: 2.9.0
 Summary: Python package for interacting with Sumo in an FMU setting
 Author: Equinor
 License:                                  Apache License

{fmu_sumo-2.8.1 → fmu_sumo-2.9.0}/src/fmu_sumo.egg-info/SOURCES.txt

@@ -45,8 +45,6 @@ src/fmu/sumo/explorer/objects/cube.py
 src/fmu/sumo/explorer/objects/dictionary.py
 src/fmu/sumo/explorer/objects/ensemble.py
 src/fmu/sumo/explorer/objects/ensembles.py
-src/fmu/sumo/explorer/objects/iteration.py
-src/fmu/sumo/explorer/objects/iterations.py
 src/fmu/sumo/explorer/objects/polygons.py
 src/fmu/sumo/explorer/objects/realization.py
 src/fmu/sumo/explorer/objects/realizations.py

fmu_sumo-2.8.1/src/fmu/sumo/explorer/objects/ensembles.py

@@ -1,90 +0,0 @@
-"""Module for searchcontext for collection of ensembles."""
-
-from copy import deepcopy
-from typing import List
-
-from fmu.sumo.explorer.objects.ensemble import Ensemble
-
-from ._search_context import SearchContext
-
-
-class Ensembles(SearchContext):
-    def __init__(self, sc, uuids):
-        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
-        self._hits = uuids
-        self._prototype = None
-        self._map = {}
-        return
-
-    def _maybe_prefetch(self, index):
-        return
-
-    async def _maybe_prefetch_async(self, index):
-        return
-
-    def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.get_field_values("fmu.ensemble.uuid.keyword")
-        return Ensembles(sc, uuids)
-
-    def get_object(self, uuid):
-        if self._prototype is None:
-            obj = super().get_object(uuid)
-            if len(self.get_field_values("fmu.case.uuid.keyword")) > 1:
-                return obj
-            # ELSE
-            self._prototype = obj.metadata
-            buckets = self.get_composite_agg(
-                {
-                    "uuid": "fmu.ensemble.uuid.keyword",
-                    "name": "fmu.ensemble.name.keyword",
-                }
-            )
-            self._map = {b["uuid"]: b for b in buckets}
-            pass
-        metadata = deepcopy(self._prototype)
-        b = self._map[uuid]
-        metadata["fmu"]["ensemble"] = b
-        return Ensemble(self._sumo, {"_id": uuid, "_source": metadata})
-
-    async def get_object_async(self, uuid):
-        if self._prototype is None:
-            obj = await super().get_object_async(uuid)
-            if (
-                len(await self.get_field_values_async("fmu.case.uuid.keyword"))
-                > 1
-            ):
-                return obj
-            # ELSE
-            self._prototype = obj.metadata
-            buckets = await self.get_composite_agg_async(
-                {
-                    "uuid": "fmu.ensemble.uuid.keyword",
-                    "name": "fmu.ensemble.name.keyword",
-                }
-            )
-            self._map = {b["uuid"]: b for b in buckets}
-            pass
-        metadata = deepcopy(self._prototype)
-        b = self._map[uuid]
-        metadata["fmu"]["ensemble"] = b
-        return Ensemble(self._sumo, {"_id": uuid, "_source": metadata})
-
-    @property
-    def classes(self) -> List[str]:
-        return ["ensemble"]
-
-    @property
-    async def classes_async(self) -> List[str]:
-        return ["ensemble"]
-
-    @property
-    def ensemblenames(self) -> List[str]:
-        return [self.get_object(uuid).ensemblename for uuid in self._hits]
-
-    @property
-    async def ensemblenames_async(self) -> List[str]:
-        return [
-            (await self.get_object_async(uuid)).ensemblename
-            for uuid in self._hits
-        ]

fmu_sumo-2.8.1/src/fmu/sumo/explorer/objects/iteration.py

@@ -1,99 +0,0 @@
-"""Module for (pseudo) iteration class."""
-
-from typing import Dict, Optional
-
-from sumo.wrapper import SumoClient
-
-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, blob: Optional[bytes] = None
-    ):
-        assert blob is None
-        Document.__init__(self, metadata)
-        SearchContext.__init__(
-            self,
-            sumo,
-            must=[{"term": {"fmu.iteration.uuid.keyword": self.uuid}}],
-        )
-        pass
-
-    def __str__(self):
-        return (
-            f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
-            f"in case {self.casename} "
-            f"in asset {self.asset}>"
-        )
-
-    def __repr__(self):
-        return self.__str__()
-
-    @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 iteration."""
-        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 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")
-
-    @property
-    def reference_realizations(self):
-        """Reference realizations in iteration. If none, return
-        realizations 0 and 1, if they exist."""
-        sc = super().reference_realizations
-        if len(sc) > 0:
-            return sc
-        else:
-            return self.filter(realization=[0, 1]).realizations
-
-    @property
-    async def reference_realizations_async(self):
-        """Reference realizations in iteration. If none, return
-        realizations 0 and 1, if they exist."""
-        sc = await super().reference_realizations_async
-        if await sc.length_async() > 0:
-            return sc
-        else:
-            return self.filter(realization=[0, 1]).realizations

fmu_sumo-2.8.1/src/fmu/sumo/explorer/objects/iterations.py

@@ -1,31 +0,0 @@
-"""Module for searchcontext for collection of iterations."""
-
-from typing import List
-
-from ._search_context import SearchContext
-
-
-class Iterations(SearchContext):
-    def __init__(self, sc, uuids):
-        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
-        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 filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.get_field_values("fmu.iteration.uuid.keyword")
-        return Iterations(sc, uuids)

fmu_sumo-2.8.1/src/fmu/sumo/explorer/objects/realizations.py

@@ -1,96 +0,0 @@
-"""Module for searchcontext for collection of realizations."""
-
-from copy import deepcopy
-from typing import List
-
-from fmu.sumo.explorer.objects.realization import Realization
-
-from ._search_context import SearchContext
-
-
-class Realizations(SearchContext):
-    def __init__(self, sc, uuids):
-        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
-        self._hits = uuids
-        self._prototype = None
-        self._map = {}
-        return
-
-    def _maybe_prefetch(self, index):
-        return
-
-    async def _maybe_prefetch_async(self, index):
-        return
-
-    def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.get_field_values("fmu.realization.uuid.keyword")
-        return Realizations(self, uuids)
-
-    def get_object(self, uuid):
-        if self._prototype is None:
-            obj = super().get_object(uuid)
-            if len(self.get_field_values("fmu.realization.uuid.keyword")) == 1:
-                return obj
-            # ELSE
-            self._prototype = obj.metadata
-            buckets = self.get_composite_agg(
-                {
-                    "uuid": "fmu.realization.uuid.keyword",
-                    "name": "fmu.realization.name.keyword",
-                    "id": "fmu.realization.id",
-                }
-            )
-            self._map = {b["uuid"]: b for b in buckets}
-            pass
-        metadata = deepcopy(self._prototype)
-        b = self._map[uuid]
-        metadata["fmu"]["realization"] = b
-        return Realization(self._sumo, {"_id": uuid, "_source": metadata})
-
-    async def get_object_async(self, uuid):
-        if self._prototype is None:
-            obj = await super().get_object_async(uuid)
-            if (
-                len(
-                    await self.get_field_values_async(
-                        "fmu.realization.uuid.keyword"
-                    )
-                )
-                == 1
-            ):
-                return obj
-            # ELSE
-            self._prototype = obj.metadata
-            buckets = await self.get_composite_agg_async(
-                {
-                    "uuid": "fmu.realization.uuid.keyword",
-                    "name": "fmu.realization.name.keyword",
-                    "id": "fmu.realization.id",
-                }
-            )
-            self._map = {b["uuid"]: b for b in buckets}
-            pass
-        metadata = deepcopy(self._prototype)
-        b = self._map[uuid]
-        metadata["fmu"]["realization"] = b
-        return Realization(self._sumo, {"_id": uuid, "_source": metadata})
-
-    @property
-    def classes(self) -> List[str]:
-        return ["realization"]
-
-    @property
-    async def classes_async(self) -> List[str]:
-        return ["realization"]
-
-    @property
-    def realizationids(self) -> List[int]:
-        return [self.get_object(uuid).realizationid for uuid in self._hits]
-
-    @property
-    async def realizationids_async(self) -> List[int]:
-        return [
-            (await self.get_object_async(uuid)).realizationid
-            for uuid in self._hits
-        ]