fmu-sumo 2.8.2__py3-none-any.whl → 2.10.0__py3-none-any.whl

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.2'
-__version_tuple__ = version_tuple = (2, 8, 2)
+__version__ = version = '2.10.0'
+__version_tuple__ = version_tuple = (2, 10, 0)
 
 __commit_id__ = commit_id = None

fmu/sumo/explorer/filters.py

@@ -22,7 +22,7 @@ class Filters:
     observations = {
         "bool": {
             "must_not": [
-                {"exists": {"field": "fmu.iteration.name.keyword"}},
+                {"exists": {"field": "fmu.ensemble.name.keyword"}},
                 {"exists": {"field": "fmu.realization.id"}},
             ]
         }

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/explorer/objects/_child.py

@@ -33,7 +33,7 @@ class Child(Document):
                 return (
                     f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
                     f"in realization {self.realization} "
-                    f"in iteration {self.iteration} "
+                    f"in ensemble {self.ensemble} "
                     f"in case {self.casename} "
                     f"in asset {self.asset}>"
                 )
@@ -41,7 +41,7 @@ class Child(Document):
                 return (
                     f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
                     f"in operation {self.operationname} "
-                    f"in iteration {self.iteration} "
+                    f"in ensemble {self.ensemble} "
                     f"in case {self.casename} "
                     f"in asset {self.asset}>"
                 )
@@ -94,8 +94,7 @@ class Child(Document):
     @property
     def template_path(self) -> str:
         return "/".join(
-            ["{realization}", "{iteration}"]
-            + self.relative_path.split("/")[2:]
+            ["{realization}", "{ensemble}"] + self.relative_path.split("/")[2:]
         )
 
     @property
@@ -138,11 +137,6 @@ class Child(Document):
         """Object realization"""
         return self.get_property("fmu.realization.id")
 
-    @property
-    def iteration(self) -> str:
-        """Object iteration"""
-        return self.get_property("fmu.iteration.name")
-
     @property
     def ensemble(self) -> str:
         """Object ensemble"""

fmu/sumo/explorer/objects/_search_context.py

@@ -64,19 +64,16 @@ def _gen_filter_gen(attr):
 def _gen_filter_stage(attr):
     """Match property against either single value or list of values.
     If the value given is a boolean, tests for existence or not of the property.
-    In addition, if the value is or includes either "iteration" or "ensemble",
-    expand to include both values.
+    In addition, if the value is or includes "ensemble" expand to include it.
     """
 
     _inner = _gen_filter_gen(attr)
 
     def _fn(value):
-        if value == "iteration" or value == "ensemble":
-            return _inner(["iteration", "ensemble"])
-        elif isinstance(value, list) and set(value).intersection(
-            {"iteration", "ensemble"}
-        ):
-            return _inner(list(set(value).union({"iteration", "ensemble"})))
+        if value == "ensemble":
+            return _inner(["ensemble"])
+        elif isinstance(value, list) and set(value).intersection({"ensemble"}):
+            return _inner(list(set(value).union({"ensemble"})))
         else:
             return _inner(value)
 
@@ -156,10 +153,6 @@ _filterspec = {
     "relative_path": [_gen_filter_gen, "file.relative_path.keyword"],
     "tagname": [_gen_filter_gen, "data.tagname.keyword"],
     "dataformat": [_gen_filter_gen, "data.format.keyword"],
-    "iteration": [
-        _gen_filter_gen,
-        "fmu.iteration.name.keyword",
-    ],  # FIXME: to be removed
     "ensemble": [_gen_filter_gen, "fmu.ensemble.name.keyword"],
     "realization": [_gen_filter_gen, "fmu.realization.id"],
     "aggregation": [_gen_filter_gen, "fmu.aggregation.operation.keyword"],
@@ -368,7 +361,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 +473,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 +525,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 +599,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 +619,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 +646,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 +1071,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 +1337,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
 
@@ -1656,7 +1543,6 @@ class SearchContext:
             "class": classname,
             "entity_uuid": entityuuid,
             "ensemble_name": ensemblename,
-            "iteration_name": ensemblename,
             "operations": [operation],
         }
         if columns is not None:

fmu/sumo/explorer/objects/case.py

@@ -12,19 +12,19 @@ def _make_overview_query(id) -> Dict:
     return {
         "query": {"term": {"fmu.case.uuid.keyword": id}},
         "aggs": {
-            "iteration_uuids": {
-                "terms": {"field": "fmu.iteration.uuid.keyword", "size": 100}
+            "ensemble_uuids": {
+                "terms": {"field": "fmu.ensemble.uuid.keyword", "size": 100}
             },
-            "iteration_names": {
-                "terms": {"field": "fmu.iteration.name.keyword", "size": 100}
+            "ensemble_names": {
+                "terms": {"field": "fmu.ensemble.name.keyword", "size": 100}
             },
             "data_types": {"terms": {"field": "class.keyword", "size": 100}},
-            "iterations": {
-                "terms": {"field": "fmu.iteration.uuid.keyword", "size": 100},
+            "ensembles": {
+                "terms": {"field": "fmu.ensemble.uuid.keyword", "size": 100},
                 "aggs": {
-                    "iteration_name": {
+                    "ensemble_name": {
                         "terms": {
-                            "field": "fmu.iteration.name.keyword",
+                            "field": "fmu.ensemble.name.keyword",
                             "size": 100,
                         }
                     },
@@ -49,7 +49,7 @@ class Case(Document, SearchContext):
             self, sumo, must=[{"term": {"fmu.case.uuid.keyword": self.uuid}}]
         )
         self._overview = None
-        self._iterations = None
+        self._ensembles = None
 
     @property
     def overview(self) -> Dict:
@@ -63,27 +63,27 @@ class Case(Document, SearchContext):
             res = self._sumo.post("/search", json=query)
             data = res.json()
             aggs = data["aggregations"]
-            iteration_names = extract_bucket_keys(aggs, "iteration_names")
-            iteration_uuids = extract_bucket_keys(aggs, "iteration_uuids")
+            ensemble_names = extract_bucket_keys(aggs, "ensemble_names")
+            ensemble_uuids = extract_bucket_keys(aggs, "ensemble_uuids")
             data_types = extract_bucket_keys(aggs, "data_types")
-            iterations = {}
-            for bucket in aggs["iterations"]["buckets"]:
+            ensembles = {}
+            for bucket in aggs["ensembles"]["buckets"]:
                 iterid = bucket["key"]
-                itername = extract_bucket_keys(bucket, "iteration_name")
+                itername = extract_bucket_keys(bucket, "ensemble_name")
                 minreal = bucket["minreal"]["value"]
                 maxreal = bucket["maxreal"]["value"]
                 numreal = bucket["numreal"]["value"]
-                iterations[iterid] = {
+                ensembles[iterid] = {
                     "name": itername,
                     "minreal": minreal,
                     "maxreal": maxreal,
                     "numreal": numreal,
                 }
             self._overview = {
-                "iteration_names": iteration_names,
-                "iteration_uuids": iteration_uuids,
+                "ensemble_names": ensemble_names,
+                "ensemble_uuids": ensemble_uuids,
                 "data_types": data_types,
-                "iterations": iterations,
+                "ensembles": ensembles,
             }
 
         return self._overview

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/explorer/objects/cpgrid.py

@@ -61,7 +61,7 @@ class CPGrid(Child):
         """
         sc = SearchContext(self._sumo).grid_properties.filter(
             uuid=self.caseuuid,
-            iteration=self.iteration,
+            ensemble=self.ensemble,
             realization=self.realization,
         )
         return sc.filter(

fmu/sumo/explorer/objects/cpgrid_property.py

@@ -61,7 +61,7 @@ class CPGridProperty(Child):
         """
         sc = SearchContext(self._sumo).grids.filter(
             uuid=self.caseuuid,
-            iteration=self.iteration,
+            ensemble=self.ensemble,
             realization=self.realization,
         )
         should = [

fmu/sumo/explorer/objects/ensembles.py

@@ -1,74 +1,21 @@
 """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=sc._must, must_not=sc._must_not)
+        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})
+    def __len__(self):
+        return len(self.uuids)
 
-    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})
+    async def length_async(self):
+        return len(await self.uuids_async)
 
     @property
     def classes(self) -> List[str]:
@@ -80,11 +27,8 @@ class Ensembles(SearchContext):
 
     @property
     def ensemblenames(self) -> List[str]:
-        return [self.get_object(uuid).ensemblename for uuid in self._hits]
+        return self.get_field_values("fmu.ensemble.name.keyword")
 
     @property
     async def ensemblenames_async(self) -> List[str]:
-        return [
-            (await self.get_object_async(uuid)).ensemblename
-            for uuid in self._hits
-        ]
+        return await self.get_field_values_async("fmu.ensemble.name.keyword")

fmu/sumo/explorer/objects/realization.py

@@ -26,7 +26,7 @@ class Realization(Document, SearchContext):
     def __str__(self):
         return (
             f"<{self.__class__.__name__}: {self.realizationid} {self.uuid}(uuid) "
-            f"in iteration {self.iterationname} "
+            f"in ensemble {self.ensemblename} "
             f"in case {self.casename} "
             f"in asset {self.asset}>"
         )
@@ -46,7 +46,7 @@ class Realization(Document, SearchContext):
 
     @property
     def user(self) -> str:
-        """Name of user who uploaded iteration."""
+        """Name of user who uploaded ensemble."""
         return self.get_property("fmu.case.user.id")
 
     @property
@@ -60,14 +60,14 @@ class Realization(Document, SearchContext):
         return self.get_property("fmu.case.name")
 
     @property
-    def iterationuuid(self) -> str:
-        """FMU iteration uuid"""
-        return self.get_property("fmu.iteration.uuid")
+    def ensembleuuid(self) -> str:
+        """FMU ensemble uuid"""
+        return self.get_property("fmu.ensemble.uuid")
 
     @property
-    def iterationname(self) -> str:
-        """FMU iteration name"""
-        return self.get_property("fmu.iteration.name")
+    def ensemblename(self) -> str:
+        """FMU ensemble name"""
+        return self.get_property("fmu.ensemble.name")
 
     @property
     def realizationuuid(self) -> str:

fmu/sumo/explorer/objects/realizations.py

@@ -1,80 +1,21 @@
 """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=sc._must, must_not=sc._must_not)
+        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})
+    def __len__(self):
+        return len(self.uuids)
 
-    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})
+    async def length_async(self):
+        return len(await self.uuids_async)
 
     @property
     def classes(self) -> List[str]:
@@ -86,11 +27,8 @@ class Realizations(SearchContext):
 
     @property
     def realizationids(self) -> List[int]:
-        return [self.get_object(uuid).realizationid for uuid in self._hits]
+        return self.get_field_values("fmu.realization.id")
 
     @property
     async def realizationids_async(self) -> List[int]:
-        return [
-            (await self.get_object_async(uuid)).realizationid
-            for uuid in self._hits
-        ]
+        return await self.get_field_values_async("fmu.realization.id")

{fmu_sumo-2.8.2.dist-info → fmu_sumo-2.10.0.dist-info}/METADATA

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

fmu_sumo-2.10.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+fmu/__init__.py,sha256=ftS-xRPSH-vU7fIHlnZQaCTWbNvs4owJivNW65kzsIM,85
+fmu/sumo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu/sumo/explorer/__init__.py,sha256=Bc1wd1lQO3HP3tsVyPbqaesf2boZwGdtookWp8lmG-k,317
+fmu/sumo/explorer/_version.py,sha256=2cFLkHY3I9n23ToIWm38PohvvIEYjdsebREPVvOKAiU,706
+fmu/sumo/explorer/cache.py,sha256=uvz8TciwBnDEwJIHa9wneC0WVWuzhUqyF3dzk4kvGNk,1037
+fmu/sumo/explorer/explorer.py,sha256=_3nUTO1E_nf6jqpivjgjKcX6rX1fx_mIG76YOM8xb-8,2931
+fmu/sumo/explorer/filters.py,sha256=Es4JiSvHfCNiN5GXxfaBIBp-1BeFRgNzUeGOTXknK7s,874
+fmu/sumo/explorer/timefilter.py,sha256=AQHa18vkCz2BzH7X9GR1ypmNxfvI4gExh_jxAVYrDjc,6260
+fmu/sumo/explorer/objects/__init__.py,sha256=KoZ-Wo1YUIkWN1aGKu-xbQDkQlZQTP5oUwTRUyVoV9U,569
+fmu/sumo/explorer/objects/_child.py,sha256=gV4dtXSGqGSg5R1Xkh7el0SAsRzD-cdLvu8PtNYqi90,6072
+fmu/sumo/explorer/objects/_document.py,sha256=UR607n9N33vYaTSsYQoMmJUgnmS3To_uVyRSf7Vxulo,1797
+fmu/sumo/explorer/objects/_metrics.py,sha256=Z7iJ8qmvH3iY5dsSf6At_AFIzITyM0rDfum_oGmUFG8,9989
+fmu/sumo/explorer/objects/_search_context.py,sha256=cCmy5toYsIyqDCYG02ud33KSDC_UeNLmsw4MGfo06AM,64911
+fmu/sumo/explorer/objects/case.py,sha256=9ptXE1XTkAGbw_R4Nh9KgCktoq2Ahu-YoLhc2wJAKOE,3790
+fmu/sumo/explorer/objects/cases.py,sha256=6Hj9ORj4Zta-C8Q9wpFYNsOqR8q-KCXrX-mlsc1hg0o,695
+fmu/sumo/explorer/objects/cpgrid.py,sha256=3dQBiKJCbjrwIc9-Fm3dcg_kCLPXst37NI5Sl_Hk1uQ,2546
+fmu/sumo/explorer/objects/cpgrid_property.py,sha256=-URqq6I0UX4fvqi8LO2gQUF6zUoFCTvQBp_ukJR2Bdo,2692
+fmu/sumo/explorer/objects/cube.py,sha256=6pJLDajex-mblkt9YRZxtcK1XHcRZ8mlPPqJ-yDGEbA,1948
+fmu/sumo/explorer/objects/dictionary.py,sha256=9Nt8Br7H4TgXO6qc46HtV1vB40LsEQb6WjWYDT-Ve0g,1191
+fmu/sumo/explorer/objects/ensemble.py,sha256=MoGiXrtyVL8_cQt5vjh0rIA5bMMGRahPb284teQEqfs,2767
+fmu/sumo/explorer/objects/ensembles.py,sha256=ZTM74xMY8EjQjaSOgIcEMXhnJB7LDoqqdjIXXkmGZvQ,883
+fmu/sumo/explorer/objects/polygons.py,sha256=0N6sKTOGkYO6augIbBObzdovCAIF5VtA_XDzbWvd3YY,1523
+fmu/sumo/explorer/objects/realization.py,sha256=1ZvPGjoCZ_xNEHJ5Lp6-TYLuq0UHG2IymHBo9BV6koI,2474
+fmu/sumo/explorer/objects/realizations.py,sha256=KIvr6gA-rDAUfcPmsLZQ7jN83-u3SQD0Jk2j9usH-So,883
+fmu/sumo/explorer/objects/surface.py,sha256=zHBtjLCIfkRHBv39OeJjA9lq3puLTfTII6TndZTtxVI,1627
+fmu/sumo/explorer/objects/table.py,sha256=vLor3YTddHkDWZSMyWPQsddFNQ2_VXE_O-stmPIWIaQ,4900
+fmu_sumo-2.10.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fmu_sumo-2.10.0.dist-info/METADATA,sha256=FI4p5r1aza3Hs2c_3GkAo13RgYwBtenpwyPbxX3CToY,14782
+fmu_sumo-2.10.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fmu_sumo-2.10.0.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_sumo-2.10.0.dist-info/RECORD,,

{fmu_sumo-2.8.2.dist-info → fmu_sumo-2.10.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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/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.2.dist-info/RECORD

@@ -1,33 +0,0 @@
-fmu/__init__.py,sha256=ftS-xRPSH-vU7fIHlnZQaCTWbNvs4owJivNW65kzsIM,85
-fmu/sumo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fmu/sumo/explorer/__init__.py,sha256=Bc1wd1lQO3HP3tsVyPbqaesf2boZwGdtookWp8lmG-k,317
-fmu/sumo/explorer/_version.py,sha256=K2e_IVECOS4JNwYcS4GZillyIK8on3GFXEEwBIw49VU,704
-fmu/sumo/explorer/cache.py,sha256=uvz8TciwBnDEwJIHa9wneC0WVWuzhUqyF3dzk4kvGNk,1037
-fmu/sumo/explorer/explorer.py,sha256=_3nUTO1E_nf6jqpivjgjKcX6rX1fx_mIG76YOM8xb-8,2931
-fmu/sumo/explorer/filters.py,sha256=_t2PmHeTY9XiBvQeEGM-BpudWUaxIfyUSdNyG70xfRU,875
-fmu/sumo/explorer/timefilter.py,sha256=AQHa18vkCz2BzH7X9GR1ypmNxfvI4gExh_jxAVYrDjc,6260
-fmu/sumo/explorer/objects/__init__.py,sha256=72G0yfWWMTXA-oZw5GMRkrWvQqAYfadjerEwsyndCzc,637
-fmu/sumo/explorer/objects/_child.py,sha256=7CJiBGfmtK7zNDUv6NLWphHMMtC8M386VyrGhuHq4dk,6222
-fmu/sumo/explorer/objects/_document.py,sha256=UR607n9N33vYaTSsYQoMmJUgnmS3To_uVyRSf7Vxulo,1797
-fmu/sumo/explorer/objects/_metrics.py,sha256=Z7iJ8qmvH3iY5dsSf6At_AFIzITyM0rDfum_oGmUFG8,9989
-fmu/sumo/explorer/objects/_search_context.py,sha256=2JP1Y7T6na5kUFfIj7UMlKlVT5waLrGMx5zkIr_PnB8,68939
-fmu/sumo/explorer/objects/case.py,sha256=fKp7X43ETLE1RaH3rMYxZiIuduRmf0JSnJ5gRoUgNPE,3813
-fmu/sumo/explorer/objects/cases.py,sha256=_6q8rXWUeJgHGF1b3X9rt3VQmH_HE7uPU0Id4Fmtq_E,659
-fmu/sumo/explorer/objects/cpgrid.py,sha256=nuRgZ6FVEOPZT1ibd-rJhlbYYZ6BuUxXZPzovcH0kVc,2548
-fmu/sumo/explorer/objects/cpgrid_property.py,sha256=PqqR05oKKKiTTG0iDO9V6TADdHY7VUsLHjai6SqahVo,2694
-fmu/sumo/explorer/objects/cube.py,sha256=6pJLDajex-mblkt9YRZxtcK1XHcRZ8mlPPqJ-yDGEbA,1948
-fmu/sumo/explorer/objects/dictionary.py,sha256=9Nt8Br7H4TgXO6qc46HtV1vB40LsEQb6WjWYDT-Ve0g,1191
-fmu/sumo/explorer/objects/ensemble.py,sha256=MoGiXrtyVL8_cQt5vjh0rIA5bMMGRahPb284teQEqfs,2767
-fmu/sumo/explorer/objects/ensembles.py,sha256=O9Nfjl8-SMf1tJQKWf0pTEHeN5vfLWlPRXegkwkboKE,2814
-fmu/sumo/explorer/objects/iteration.py,sha256=vXaH6G93pNPvufgliqRSs4fpqgNvgxa7QI0G0ucgr_U,2784
-fmu/sumo/explorer/objects/iterations.py,sha256=ZRQOxPl6MpX7JV7lfvtXp8mGLHl37pl3-F9YAXYfRgc,778
-fmu/sumo/explorer/objects/polygons.py,sha256=0N6sKTOGkYO6augIbBObzdovCAIF5VtA_XDzbWvd3YY,1523
-fmu/sumo/explorer/objects/realization.py,sha256=HK47WyX6kwe6ZoHaGHeTWEno86Wkh9THLOtEzOt1FGE,2483
-fmu/sumo/explorer/objects/realizations.py,sha256=OdaNVEZ29Fnr3i8SP2oWn01st3aMTN6U0ph-BsPXmbA,3064
-fmu/sumo/explorer/objects/surface.py,sha256=zHBtjLCIfkRHBv39OeJjA9lq3puLTfTII6TndZTtxVI,1627
-fmu/sumo/explorer/objects/table.py,sha256=vLor3YTddHkDWZSMyWPQsddFNQ2_VXE_O-stmPIWIaQ,4900
-fmu_sumo-2.8.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fmu_sumo-2.8.2.dist-info/METADATA,sha256=z0Hb_SuYDUNinBMw-yJeVNaqqCRr9clVZ3sL2XAyack,14781
-fmu_sumo-2.8.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_sumo-2.8.2.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_sumo-2.8.2.dist-info/RECORD,,