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

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

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

{fmu_sumo-2.9.0 → fmu_sumo-2.11.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.9.0'
-__version_tuple__ = version_tuple = (2, 9, 0)
+__version__ = version = '2.11.0'
+__version_tuple__ = version_tuple = (2, 11, 0)
 
-__commit_id__ = commit_id = 'gbcff66149'
+__commit_id__ = commit_id = 'gb7f4183e8'

{fmu_sumo-2.9.0 → fmu_sumo-2.11.0}/src/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-2.9.0 → fmu_sumo-2.11.0}/src/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-2.9.0 → fmu_sumo-2.11.0}/src/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"],
@@ -1285,8 +1278,8 @@ class SearchContext:
                                 "must": [
                                     {"term": {"class.keyword": "dictionary"}},
                                     {
-                                        "exists": {
-                                            "field": "fmu.realization.id"
+                                        "term": {
+                                            "fmu.context.stage.keyword": "realization"
                                         }
                                     },
                                 ]
@@ -1297,8 +1290,11 @@ class SearchContext:
                                 "must": [
                                     {"term": {"class.keyword": "table"}},
                                     {
-                                        "exists": {
-                                            "field": "fmu.aggregation.operation"
+                                        "terms": {
+                                            "fmu.context.stage.keyword": [
+                                                "ensemble",
+                                                "iteration",
+                                            ]
                                         }
                                     },
                                 ]
@@ -1550,7 +1546,6 @@ class SearchContext:
             "class": classname,
             "entity_uuid": entityuuid,
             "ensemble_name": ensemblename,
-            "iteration_name": ensemblename,
             "operations": [operation],
         }
         if columns is not None:

{fmu_sumo-2.9.0 → fmu_sumo-2.11.0}/src/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-2.9.0 → fmu_sumo-2.11.0}/src/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-2.9.0 → fmu_sumo-2.11.0}/src/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-2.9.0 → fmu_sumo-2.11.0}/src/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-2.9.0 → fmu_sumo-2.11.0/src/fmu_sumo.egg-info}/PKG-INFO

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

{fmu_sumo-2.9.0 → fmu_sumo-2.11.0}/tests/test_explorer.py

@@ -213,13 +213,13 @@ def test_case_surfaces_filter(test_case: Case):
     real_surfs = test_case.surfaces.filter(realization=True)
     assert len(real_surfs) == 212
 
-    # filter on iteration
-    real_surfs = real_surfs.filter(iteration="iter-0")
+    # filter on ensemble
+    real_surfs = real_surfs.filter(ensemble="iter-0")
     assert len(real_surfs) == 212
 
     # for surf in real_surfs:
-    #     assert surf.iteration == "iter-0"
-    its = real_surfs.get_field_values("fmu.iteration.name.keyword")
+    #     assert surf.ensemble == "iter-0"
+    its = real_surfs.get_field_values("fmu.ensemble.name.keyword")
     assert len(its) == 1 and its[0] == "iter-0"
 
     # filter on name
@@ -230,9 +230,9 @@ def test_case_surfaces_filter(test_case: Case):
     assert len(real_surfs) == 56
 
     # for surf in real_surfs:
-    #     assert surf.iteration == "iter-0"
+    #     assert surf.ensemble == "iter-0"
     #     assert surf.name == "Valysar Fm."
-    its = real_surfs.get_field_values("fmu.iteration.name.keyword")
+    its = real_surfs.get_field_values("fmu.ensemble.name.keyword")
     assert len(its) == 1 and its[0] == "iter-0"
     names = real_surfs.get_field_values("data.name.keyword")
     assert len(names) == 1 and names[0] == "Valysar Fm."
@@ -252,10 +252,10 @@ def test_case_surfaces_filter(test_case: Case):
     assert len(real_surfs) == 4
 
     # for surf in real_surfs:
-    #     assert surf.iteration == "iter-0"
+    #     assert surf.ensemble == "iter-0"
     #     assert surf.name == "Valysar Fm."
     #     assert surf.tagname == "FACIES_Fraction_Channel"
-    its = real_surfs.get_field_values("fmu.iteration.name.keyword")
+    its = real_surfs.get_field_values("fmu.ensemble.name.keyword")
     assert len(its) == 1 and its[0] == "iter-0"
     names = real_surfs.get_field_values("data.name.keyword")
     assert len(names) == 1 and names[0] == "Valysar Fm."
@@ -273,7 +273,7 @@ def test_case_surfaces_filter(test_case: Case):
     real_surfs = real_surfs.filter(realization=0)
     assert len(real_surfs) == 1
 
-    assert real_surfs[0].iteration == "iter-0"
+    assert real_surfs[0].ensemble == "iter-0"
     assert real_surfs[0].name == "Valysar Fm."
     assert real_surfs[0].tagname == "FACIES_Fraction_Channel"
     assert real_surfs[0].realization == 0