fmu-sumo 2.4.10__py3-none-any.whl → 2.6.0__py3-none-any.whl

fmu/sumo/explorer/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '2.4.10'
-__version_tuple__ = version_tuple = (2, 4, 10)
+__version__ = version = '2.6.0'
+__version_tuple__ = version_tuple = (2, 6, 0)
+
+__commit_id__ = commit_id = None

fmu/sumo/explorer/objects/_child.py

@@ -21,7 +21,7 @@ class Child(Document):
         self._sumo = sumo
         self._blob = blob
 
-    def __repr__(self):
+    def __str__(self):
         if self.stage == "case" and self.__class__.__name__ != "Case":
             return (
                 f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
@@ -46,7 +46,10 @@ class Child(Document):
                     f"in asset {self.asset}>"
                 )
             else:
-                return super().__repr__()
+                return super().__str__()
+
+    def __repr__(self):
+        return self.__str__()
 
     @property
     def blob(self) -> BytesIO:

fmu/sumo/explorer/objects/_document.py

@@ -1,6 +1,5 @@
 """Contains class for one document"""
 
-import json
 import re
 from typing import Any, Dict, List, Union
 
@@ -20,14 +19,14 @@ class Document:
         self._metadata = metadata["_source"]
 
     def __str__(self):
-        return f"{json.dumps(self.metadata, indent=4)}"
-
-    def __repr__(self):
         return (
             f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
             f"in asset {self.asset}>"
         )
 
+    def __repr__(self):
+        return self.__str__()
+
     @property
     def uuid(self):
         """Return uuid

fmu/sumo/explorer/objects/_metrics.py

@@ -272,3 +272,56 @@ class Metrics:
                 "percentiles", field=field, percents=percents
             )
         )["values"]
+
+    def _fnv1a_script(self, field):
+        return {
+            "init_script": """
+                state.h = state.count = state.total = 0L;
+            """,
+            "map_script": f"""
+                state.total++;
+                if (doc['{field}'].size() == 0) return;
+                def s = doc.get('{field}').value;
+                long h = -3750763034362895579L;
+                for (int i = 0; i < s.length(); i++) {{
+                    h ^= (long) s.charAt(i);
+                    h *= 1099511628211L;
+                }}
+                state.h ^= h;
+                state.count++;
+            """,
+            "combine_script": """
+                return state;
+            """,
+            "reduce_script": """
+                long h = 0, c = 0, t = 0;
+                for (st in states) {
+                    h ^= st.h; c += st.count; t += st.total
+                }
+                return ['checksum': Long.toHexString(h), 'docs_in_checksum': c, 'docs_total': t];
+            """,
+        }
+
+    def fnv1a(self, field):
+        """Compute the 64-bit FNV-1a checksum for field over the current set of objects.
+
+        Arguments:
+            - field (str): the name of a property in the metadata.
+
+        Returns:
+            - a dict with the keys "docs_all", "docs_seen" and "xor_fnv64_hex".
+        """
+        return self._aggregate("scripted_metric", **self._fnv1a_script(field))
+
+    async def fnv1a_async(self, field):
+        """Compute the 64-bit FNV-1a checksum for field over the current set of objects.
+
+        Arguments:
+            - field (str): the name of a property in the metadata.
+
+        Returns:
+            - a dict with the keys "docs_all", "docs_seen" and "xor_fnv64_hex".
+        """
+        return await self._aggregate_async(
+            "scripted_metric", **self._fnv1a_script(field)
+        )

fmu/sumo/explorer/objects/_search_context.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import warnings
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Union
@@ -299,14 +298,6 @@ class SearchContext:
         return
 
     def __str__(self):
-        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):
         cls = self.__class__.__name__
         length = len(self)
         if length == 0:
@@ -317,6 +308,9 @@ class SearchContext:
             else:
                 return f"<{cls}: {length} objects of types {self.classes}>"
 
+    def __repr__(self):
+        return self.__str__()
+
     @property
     def _query(self):
         must = self._must[:]
@@ -581,6 +575,66 @@ 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
 
@@ -603,7 +657,10 @@ class SearchContext:
             hits = res.json()["hits"]["hits"]
 
             if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
+                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)
 
@@ -632,7 +689,10 @@ class SearchContext:
             hits = res.json()["hits"]["hits"]
 
             if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
+                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)
 
@@ -869,6 +929,26 @@ class SearchContext:
         """
         return self.get_field_values(field)
 
+    def match_field_values(self, field: str, patterns: list[str]) -> list[str]:
+        query = {
+            "query": self._query,
+            "size": 0,
+            "aggs": {
+                "values": {
+                    "terms": {
+                        "field": field,
+                        "include": "|".join(patterns),
+                        "size": 1000,
+                    }
+                }
+            },
+        }
+        res = self._sumo.post("/search", json=query).json()
+        return [
+            bucket["key"]
+            for bucket in res["aggregations"]["values"]["buckets"]
+        ]
+
     async def get_field_values_and_counts_async(
         self, field: str
     ) -> Dict[str, int]:
@@ -918,6 +998,28 @@ class SearchContext:
         """
         return await self.get_field_values_async(field)
 
+    async def match_field_values_async(
+        self, field: str, patterns: list[str]
+    ) -> list[str]:
+        query = {
+            "query": self._query,
+            "size": 0,
+            "aggs": {
+                "values": {
+                    "terms": {
+                        "field": field,
+                        "include": "|".join(patterns),
+                        "size": 1000,
+                    }
+                }
+            },
+        }
+        res = (await self._sumo.post_async("/search", json=query)).json()
+        return [
+            bucket["key"]
+            for bucket in res["aggregations"]["values"]["buckets"]
+        ]
+
     _timestamp_query = {
         "bool": {
             "must": [{"exists": {"field": "data.time.t0"}}],
@@ -1012,6 +1114,22 @@ class SearchContext:
         )
         return objects.Realizations(self, uuids)
 
+    @property
+    def reference_realizations(self):
+        """Reference realizations from current selection."""
+        return self.filter(
+            cls="realization",
+            complex={"term": {"fmu.realization.is_reference": True}},
+        )
+
+    @property
+    async def reference_realizations_async(self):
+        """Reference realizations from current selection."""
+        return self.filter(
+            cls="realization",
+            complex={"term": {"fmu.realization.is_reference": True}},
+        )
+
     @property
     def template_paths(self) -> List[str]:
         return {obj.template_path for obj in self}
@@ -1236,24 +1354,6 @@ class SearchContext:
         """
         return await self._get_object_by_class_and_uuid_async("case", uuid)
 
-    def _iteration_query(self, uuid):
-        return {
-            "query": {"term": {"fmu.iteration.uuid.keyword": {"value": uuid}}},
-            "size": 1,
-            "_source": {
-                "includes": [
-                    "$schema",
-                    "class",
-                    "source",
-                    "version",
-                    "access",
-                    "masterdata",
-                    "fmu.case",
-                    "fmu.iteration",
-                ],
-            },
-        }
-
     def get_iteration_by_uuid(self, uuid: str) -> objects.Iteration:
         """Get iteration object by uuid
 
@@ -1262,23 +1362,9 @@ class SearchContext:
 
         Returns: iteration object
         """
-        try:
-            obj = self.get_object(uuid)
-            assert isinstance(obj, objects.Iteration)
-            return obj
-        except Exception:
-            res = self._sumo.post(
-                "/search", json=self._iteration_query(uuid)
-            ).json()
-            hits = res["hits"]["hits"]
-            if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
-            obj = hits[0]
-            obj["_id"] = uuid
-            obj["_source"]["class"] = "iteration"
-            ret = self._to_sumo(obj)
-            self._cache.put(uuid, ret)
-            return ret
+        obj = self.get_object(uuid)
+        assert isinstance(obj, objects.Iteration)
+        return obj
 
     async def get_iteration_by_uuid_async(
         self, uuid: str
@@ -1290,43 +1376,9 @@ class SearchContext:
 
         Returns: iteration object
         """
-        try:
-            obj = await self.get_object_async(uuid)
-            assert isinstance(obj, objects.Iteration)
-            return obj
-        except Exception:
-            res = (
-                await self._sumo.post_async(
-                    "/search", json=self._iteration_query(uuid)
-                )
-            ).json()
-            hits = res["hits"]["hits"]
-            if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
-            obj = hits[0]
-            obj["_id"] = uuid
-            obj["_source"]["class"] = "iteration"
-            ret = self._to_sumo(obj)
-            self._cache.put(uuid, ret)
-            return ret
-
-    def _ensemble_query(self, uuid):
-        return {
-            "query": {"term": {"fmu.ensemble.uuid.keyword": {"value": uuid}}},
-            "size": 1,
-            "_source": {
-                "includes": [
-                    "$schema",
-                    "class",
-                    "source",
-                    "version",
-                    "access",
-                    "masterdata",
-                    "fmu.case",
-                    "fmu.ensemble",
-                ],
-            },
-        }
+        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
@@ -1336,23 +1388,9 @@ class SearchContext:
 
         Returns: ensemble object
         """
-        try:
-            obj = self.get_object(uuid)
-            assert isinstance(obj, objects.Ensemble)
-            return obj
-        except Exception:
-            res = self._sumo.post(
-                "/search", json=self._ensemble_query(uuid)
-            ).json()
-            hits = res["hits"]["hits"]
-            if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
-            obj = hits[0]
-            obj["_id"] = uuid
-            obj["_source"]["class"] = "ensemble"
-            ret = self._to_sumo(obj)
-            self._cache.put(uuid, ret)
-            return ret
+        obj = self.get_object(uuid)
+        assert isinstance(obj, objects.Ensemble)
+        return obj
 
     async def get_ensemble_by_uuid_async(self, uuid: str) -> objects.Ensemble:
         """Get ensemble object by uuid
@@ -1362,47 +1400,9 @@ class SearchContext:
 
         Returns: ensemble object
         """
-        try:
-            obj = await self.get_object_async(uuid)
-            assert isinstance(obj, objects.Ensemble)
-            return obj
-        except Exception:
-            res = (
-                await self._sumo.post_async(
-                    "/search", json=self._ensemble_query(uuid)
-                )
-            ).json()
-            hits = res["hits"]["hits"]
-            if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
-            obj = hits[0]
-            obj["_id"] = uuid
-            obj["_source"]["class"] = "ensemble"
-            ret = self._to_sumo(obj)
-            self._cache.put(uuid, ret)
-            return ret
-
-    def _realization_query(self, uuid) -> Dict:
-        return {
-            "query": {
-                "term": {"fmu.realization.uuid.keyword": {"value": uuid}}
-            },
-            "size": 1,
-            "_source": {
-                "includes": [
-                    "$schema",
-                    "class",
-                    "source",
-                    "version",
-                    "access",
-                    "masterdata",
-                    "fmu.case",
-                    "fmu.iteration",
-                    "fmu.ensemble",
-                    "fmu.realization",
-                ],
-            },
-        }
+        obj = await self.get_object_async(uuid)
+        assert isinstance(obj, objects.Ensemble)
+        return obj
 
     def get_realization_by_uuid(self, uuid: str) -> objects.Realization:
         """Get realization object by uuid
@@ -1412,21 +1412,9 @@ class SearchContext:
 
         Returns: realization object
         """
-        try:
-            obj = self.get_object(uuid)
-            assert isinstance(obj, objects.Realization)
-            return obj
-        except Exception:
-            res = self._sumo.post(
-                "/search", json=self._realization_query(uuid)
-            ).json()
-            hits = res["hits"]["hits"]
-            if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
-            obj = hits[0]
-            obj["_id"] = uuid
-            obj["_source"]["class"] = "realization"
-            return self._to_sumo(obj)
+        obj = self.get_object(uuid)
+        assert isinstance(obj, objects.Realization)
+        return obj
 
     async def get_realization_by_uuid_async(
         self, uuid: str
@@ -1438,23 +1426,9 @@ class SearchContext:
 
         Returns: realization object
         """
-        try:
-            obj = await self.get_object_async(uuid)
-            assert isinstance(obj, objects.Realization)
-            return obj
-        except Exception:
-            res = (
-                await self._sumo.post_async(
-                    "/search", json=self._realization_query(uuid)
-                )
-            ).json()
-            hits = res["hits"]["hits"]
-            if len(hits) == 0:
-                raise Exception(f"Document not found: {uuid}")
-            obj = hits[0]
-            obj["_id"] = uuid
-            obj["_source"]["class"] = "realization"
-            return self._to_sumo(obj)
+        obj = await self.get_object_async(uuid)
+        assert isinstance(obj, objects.Realization)
+        return obj
 
     def get_surface_by_uuid(self, uuid: str) -> objects.Surface:
         """Get surface object by uuid
@@ -1543,7 +1517,7 @@ class SearchContext:
 
     def __verify_aggregation_operation(
         self, sres
-    ) -> Tuple[str, str, str, str]:
+    ) -> Tuple[str, str, str, str, str]:
         tot_hits = sres["hits"]["total"]["value"]
         if tot_hits == 0:
             raise Exception("No matching realizations found.")
@@ -1570,18 +1544,38 @@ class SearchContext:
             "key"
         ]
         classname = sres["aggregations"]["class"]["buckets"][0]["key"]
-        return caseuuid, classname, entityuuid, ensemblename
+
+        return caseuuid, classname, entityuuid, ensemblename, tot_hits
 
     def _verify_aggregation_operation(
-        self, columns, operation
+        self, columns
     ) -> Tuple[str, str, str, str]:
-        assert columns is None or len(columns) == 1, (
-            "Exactly one column required for collection aggregation."
-        )
         sc = self if columns is None else self.filter(column=columns)
         query = sc.__prepare_verify_aggregation_query()
         sres = sc._sumo.post("/search", json=query).json()
-        return sc.__verify_aggregation_operation(sres)
+        caseuuid, classname, entityuuid, ensemblename, tot_hits = (
+            sc.__verify_aggregation_operation(sres)
+        )
+
+        if (
+            classname != "surface"
+            and isinstance(columns, list)
+            and len(columns) == 1
+        ):
+            sc = SearchContext(
+                sumo=self._sumo,
+            ).filter(
+                cls=classname,
+                realization=True,
+                entity=entityuuid,
+                ensemble=ensemblename,
+            )
+
+            if len(sc) != tot_hits:
+                raise Exception(
+                    "Filtering on realization is not allowed for table and parameter aggregation."
+                )
+        return caseuuid, classname, entityuuid, ensemblename
 
     def __prepare_aggregation_spec(
         self, caseuuid, classname, entityuuid, ensemblename, operation, columns
@@ -1598,9 +1592,11 @@ class SearchContext:
             spec["columns"] = columns
         return spec
 
-    def _aggregate(self, columns=None, operation=None) -> objects.Child:
+    def _aggregate(
+        self, columns=None, operation=None, no_wait=False
+    ) -> objects.Child | httpx.Response:
         caseuuid, classname, entityuuid, ensemblename = (
-            self._verify_aggregation_operation(columns, operation)
+            self._verify_aggregation_operation(columns)
         )
         spec = self.__prepare_aggregation_spec(
             caseuuid, classname, entityuuid, ensemblename, operation, columns
@@ -1612,36 +1608,91 @@ class SearchContext:
             print(ex.response.reason_phrase)
             print(ex.response.text)
             raise ex
+        if no_wait:
+            return res
+        # ELSE
         res = self._sumo.poll(res).json()
         return self._to_sumo(res)
 
-    def aggregate(self, columns=None, operation=None) -> objects.Child:
+    def aggregate(
+        self, columns=None, operation=None, no_wait=False
+    ) -> objects.Child | httpx.Response:
+        assert columns is None or len(columns) == 1, (
+            "Exactly one column required for collection aggregation."
+        )
         sc = self.filter(realization=True, column=columns)
         if len(sc.hidden) > 0:
-            return sc.hidden._aggregate(columns=columns, operation=operation)
-        else:
-            return sc.visible._aggregate(columns=columns, operation=operation)
+            sc = sc.hidden
+        return sc._aggregate(
+            columns=columns, operation=operation, no_wait=no_wait
+        )
+
+    def batch_aggregate(self, columns=None, operation=None, no_wait=False):
+        """Aggregate one or more columns for the current context.
+
+        Args:
+            columns: list of column names or regular expressions for column names.
+            operation: must be "collection"
+            no_wait: set to True if the client handles polling itself.
+
+        Returns:
+            list of column names that occur in the current context and match the names/patterns.
+        """
+        assert operation == "collection"
+        assert type(columns) is list and len(columns) > 0
+        assert len(columns) < 1000, (
+            "Maximum 1000 columns allowed for a single call to batch_aggregate."
+        )
+        sc = self.filter(realization=True, column=columns)
+        if len(sc.hidden) > 0:
+            sc = sc.hidden
+        res = sc._aggregate(columns=columns, operation=operation, no_wait=True)
+        assert type(res) is httpx.Response
+        if no_wait:
+            return res
+        # ELSE
+        return self._sumo.poll(res)
 
     async def _verify_aggregation_operation_async(
-        self, columns, operation
+        self, columns
     ) -> Tuple[str, str, str, str]:
-        assert columns is None or len(columns) == 1, (
-            "Exactly one column required for collection aggregation."
-        )
         sc = self if columns is None else self.filter(column=columns)
         query = sc.__prepare_verify_aggregation_query()
         sres = (await self._sumo.post_async("/search", json=query)).json()
-        return sc.__verify_aggregation_operation(sres)
+        caseuuid, classname, entityuuid, ensemblename, tot_hits = (
+            sc.__verify_aggregation_operation(sres)
+        )
+
+        if (
+            classname != "surface"
+            and isinstance(columns, list)
+            and len(columns) == 1
+        ):
+            sc = SearchContext(
+                sumo=self._sumo,
+            ).filter(
+                cls=classname,
+                realization=True,
+                entity=entityuuid,
+                ensemble=ensemblename,
+            )
+
+            tot_reals = await sc.length_async()
+            if tot_reals != tot_hits:
+                raise Exception(
+                    "Filtering on realization is not allowed for table and parameter aggregation."
+                )
+        return caseuuid, classname, entityuuid, ensemblename
 
     async def _aggregate_async(
-        self, columns=None, operation=None
-    ) -> objects.Child:
+        self, columns=None, operation=None, no_wait=False
+    ) -> objects.Child | httpx.Response:
         (
             caseuuid,
             classname,
             entityuuid,
             ensemblename,
-        ) = await self._verify_aggregation_operation_async(columns, operation)
+        ) = await self._verify_aggregation_operation_async(columns)
         spec = self.__prepare_aggregation_spec(
             caseuuid, classname, entityuuid, ensemblename, operation, columns
         )
@@ -1652,24 +1703,59 @@ class SearchContext:
             print(ex.response.reason_phrase)
             print(ex.response.text)
             raise ex
+        if no_wait:
+            return res
+        # ELSE
         res = (await self._sumo.poll_async(res)).json()
         return self._to_sumo(res)
 
     async def aggregate_async(
-        self, columns=None, operation=None
-    ) -> objects.Child:
+        self, columns=None, operation=None, no_wait=False
+    ) -> objects.Child | httpx.Response:
+        assert columns is None or len(columns) == 1, (
+            "Exactly one column required for collection aggregation."
+        )
         sc = self.filter(realization=True, column=columns)
         length_hidden = await sc.hidden.length_async()
         if length_hidden > 0:
-            return await sc.hidden._aggregate_async(
-                columns=columns, operation=operation
-            )
-        else:
-            return await sc.visible._aggregate_async(
-                columns=columns, operation=operation
-            )
+            sc = sc.hidden
+        return await sc._aggregate_async(
+            columns=columns, operation=operation, no_wait=no_wait
+        )
+
+    async def batch_aggregate_async(
+        self, columns=None, operation=None, no_wait=False
+    ):
+        """Aggregate one or more columns for the current context.
+
+        Args:
+            columns: list of column names or regular expressions for column names.
+            operation: must be "collection"
+            no_wait: set to True if the client handles polling itself.
+
+        Returns:
+            list of column names that occur in the current context and match the names/patterns.
+        """
+        assert operation == "collection"
+        assert type(columns) is list and len(columns) > 0
+        assert len(columns) < 1000, (
+            "Maximum 1000 columns allowed for a single call to batch_aggregate_async."
+        )
+        sc = self.filter(realization=True, column=columns)
+        if len(sc.hidden) > 0:
+            sc = sc.hidden
+        res = await sc._aggregate_async(
+            columns=columns, operation=operation, no_wait=True
+        )
+        assert type(res) is httpx.Response
+        if no_wait:
+            return res
+        # ELSE
+        return await self._sumo.poll_async(res)
 
-    def aggregation(self, column=None, operation=None) -> objects.Child:
+    def aggregation(
+        self, column=None, operation=None, no_wait=False
+    ) -> objects.Child | httpx.Response:
         assert operation is not None
         assert column is None or isinstance(column, str)
         sc = self.filter(aggregation=operation, column=column)
@@ -1691,11 +1777,12 @@ class SearchContext:
         return self.filter(realization=True).aggregate(
             columns=[column] if column is not None else None,
             operation=operation,
+            no_wait=no_wait,
         )
 
     async def aggregation_async(
-        self, column=None, operation=None
-    ) -> objects.Child:
+        self, column=None, operation=None, no_wait=False
+    ) -> objects.Child | httpx.Response:
         assert operation is not None
         assert column is None or isinstance(column, str)
         sc = self.filter(aggregation=operation, column=column)
@@ -1720,6 +1807,7 @@ class SearchContext:
         return await self.filter(realization=True).aggregate_async(
             columns=[column] if column is not None else None,
             operation=operation,
+            no_wait=no_wait,
         )
 
     @deprecation.deprecated(

fmu/sumo/explorer/objects/ensemble.py

@@ -23,13 +23,16 @@ class Ensemble(Document, SearchContext):
         )
         pass
 
-    def __repr__(self):
+    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"""
@@ -74,3 +77,23 @@ class Ensemble(Document, SearchContext):
     def uuid(self) -> str:
         """FMU ensemble uuid"""
         return self.get_property("fmu.ensemble.uuid")
+
+    @property
+    def reference_realizations(self):
+        """Reference realizations in ensemble. 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 ensemble. 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/ensembles.py

@@ -1,6 +1,6 @@
 """Module for searchcontext for collection of ensembles."""
 
-from typing import Dict, List
+from typing import List
 
 from ._search_context import SearchContext
 
@@ -25,42 +25,6 @@ class Ensembles(SearchContext):
     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 = super().filter(**kwargs)
         uuids = sc.get_field_values("fmu.ensemble.uuid.keyword")

fmu/sumo/explorer/objects/iteration.py

@@ -23,13 +23,16 @@ class Iteration(Document, SearchContext):
         )
         pass
 
-    def __repr__(self):
+    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"""
@@ -74,3 +77,23 @@ class Iteration(Document, SearchContext):
     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,6 +1,6 @@
 """Module for searchcontext for collection of iterations."""
 
-from typing import Dict, List
+from typing import List
 
 from ._search_context import SearchContext
 
@@ -25,42 +25,6 @@ class Iterations(SearchContext):
     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_iteration_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_iteration_by_uuid_async(uuid)
-            self._cache.put(uuid, obj)
-
-        return obj
-
     def filter(self, **kwargs):
         sc = super().filter(**kwargs)
         uuids = sc.get_field_values("fmu.iteration.uuid.keyword")

fmu/sumo/explorer/objects/realization.py

@@ -23,7 +23,7 @@ class Realization(Document, SearchContext):
         )
         pass
 
-    def __repr__(self):
+    def __str__(self):
         return (
             f"<{self.__class__.__name__}: {self.realizationid} {self.uuid}(uuid) "
             f"in iteration {self.iterationname} "
@@ -31,6 +31,9 @@ class Realization(Document, SearchContext):
             f"in asset {self.asset}>"
         )
 
+    def __repr__(self):
+        return self.__str__()
+
     @property
     def field(self) -> str:
         """Case field"""
@@ -80,3 +83,8 @@ class Realization(Document, SearchContext):
     def realizationid(self) -> int:
         """FMU realization id"""
         return self.get_property("fmu.realization.id")
+
+    @property
+    def is_reference(self) -> bool:
+        """Check if reference realization."""
+        return self.get_property("fmu.realization.is_reference") is True

fmu/sumo/explorer/objects/realizations.py

@@ -1,6 +1,6 @@
 """Module for searchcontext for collection of realizations."""
 
-from typing import Dict
+from typing import List
 
 from ._search_context import SearchContext
 
@@ -17,43 +17,26 @@ class Realizations(SearchContext):
     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_realization_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_realization_by_uuid_async(uuid)
-            self._cache.put(uuid, obj)
-
-        return obj
-
     def filter(self, **kwargs):
         sc = super().filter(**kwargs)
         uuids = sc.get_field_values("fmu.realization.uuid.keyword")
         return Realizations(self, uuids)
+
+    @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
+        ]

{fmu_sumo-2.4.10.dist-info → fmu_sumo-2.6.0.dist-info}/METADATA

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

{fmu_sumo-2.4.10.dist-info → fmu_sumo-2.6.0.dist-info}/RECORD

@@ -1,33 +1,33 @@
 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=BuCMiZ5EohpF0751Q0YbLQjmp1ReIXzBLo5Je8Kxg5w,513
+fmu/sumo/explorer/_version.py,sha256=2GXF52IIutfiInnoWGItHWB6xM45HGVQYJ3J77-iUV0,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=RrH3W3GF5Nhje7VnhmlEwG_jhX0z6CloJgdGJJzk3po,6035
-fmu/sumo/explorer/objects/_document.py,sha256=uPAkNzcOk8U4LCtXthWkm7kfU9W4HYHrrqV9HERDhe8,1835
-fmu/sumo/explorer/objects/_metrics.py,sha256=WITAFAV-3VRd-AqTg0tUwWpOChW4YFfF8ffT2fvOrAo,8144
-fmu/sumo/explorer/objects/_search_context.py,sha256=RA2KoEmnnHs6xdwLWbvTX7JXgYXhR5fCsqzzR8TnPY8,63357
+fmu/sumo/explorer/objects/_child.py,sha256=I-TVxC5JhmcuCAkj1A_dK-cUzvbQarbonX1zq59d0ZU,6088
+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=C_HaiqqnERr_WV9sRX4P9MQdGl2rEco1FpxtM32j24M,66500
 fmu/sumo/explorer/objects/case.py,sha256=fKp7X43ETLE1RaH3rMYxZiIuduRmf0JSnJ5gRoUgNPE,3813
 fmu/sumo/explorer/objects/cases.py,sha256=i2bnvk7NWIkzbdWMs3BXU7TCqD5tH2r7pg1m1QXUj3o,561
 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=PqHUKMxIyT8pMVtPjvgUNS5P3gTeDYI52CqFGB56HUA,2009
-fmu/sumo/explorer/objects/ensembles.py,sha256=Z20a9Vlx-P9Z484ikL_0X_xm5pudVjghmB0tq-_smwE,1718
-fmu/sumo/explorer/objects/iteration.py,sha256=ASZXjsxASEoVgbS-ZNpBNm3qKr1pPG0v7CAlFyiYOk4,2024
-fmu/sumo/explorer/objects/iterations.py,sha256=VzoOQSnqVRXJDCPe9nJCWNtPyVtJEraZPTJsPwXF_j4,1726
+fmu/sumo/explorer/objects/ensemble.py,sha256=MoGiXrtyVL8_cQt5vjh0rIA5bMMGRahPb284teQEqfs,2767
+fmu/sumo/explorer/objects/ensembles.py,sha256=uFtnWDgk316NRM_JvD1C7PK20gDOPQVQjCygPFhe3ZE,772
+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=k5BKuXHsLxzhMR5KId6Fly4FNygTOcShFCCMXvhjWg4,1187
-fmu/sumo/explorer/objects/realization.py,sha256=Th3zr_nT2I1HYHkBojOAKnf_RSIPc-TiDtW0X39eMRw,2259
-fmu/sumo/explorer/objects/realizations.py,sha256=4agtQFJ5pxLyWMeIzdJbkBMc8__Md-tZOj8Un4ol22c,1562
+fmu/sumo/explorer/objects/realization.py,sha256=HK47WyX6kwe6ZoHaGHeTWEno86Wkh9THLOtEzOt1FGE,2483
+fmu/sumo/explorer/objects/realizations.py,sha256=ojyQDZNEGubRE97z7c5WHK1ZnO267jsIureNeIzouAw,1120
 fmu/sumo/explorer/objects/surface.py,sha256=zHBtjLCIfkRHBv39OeJjA9lq3puLTfTII6TndZTtxVI,1627
 fmu/sumo/explorer/objects/table.py,sha256=vLor3YTddHkDWZSMyWPQsddFNQ2_VXE_O-stmPIWIaQ,4900
-fmu_sumo-2.4.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fmu_sumo-2.4.10.dist-info/METADATA,sha256=Q1_QvBNu-n_Zfo_lyZajdYVvEIE-aX9zg2yLCucwiUE,14782
-fmu_sumo-2.4.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_sumo-2.4.10.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_sumo-2.4.10.dist-info/RECORD,,
+fmu_sumo-2.6.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fmu_sumo-2.6.0.dist-info/METADATA,sha256=56_A-Dt1Bk1Q9ZfnIGVTQrTetphpp3kgI-bkquj2IFw,14781
+fmu_sumo-2.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_sumo-2.6.0.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_sumo-2.6.0.dist-info/RECORD,,