fmu-sumo 2.4.3__py3-none-any.whl → 2.4.4__py3-none-any.whl

fmu/sumo/explorer/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.4.3'
-__version_tuple__ = version_tuple = (2, 4, 3)
+__version__ = version = '2.4.4'
+__version_tuple__ = version_tuple = (2, 4, 4)

fmu/sumo/explorer/objects/_search_context.py

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
 import json
-import uuid
 import warnings
 from datetime import datetime
-from io import BytesIO
 from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Union
 
 import deprecation
@@ -1484,12 +1482,10 @@ class SearchContext:
         """
         return await self._get_object_by_class_and_uuid_async("table", uuid)
 
-    def _verify_aggregation_operation(
-        self,
-    ) -> Tuple[Dict, List[str], List[int]]:
-        query = {
+    def __prepare_verify_aggregation_query(self) -> Dict:
+        return {
             "query": self._query,
-            "size": 1,
+            "size": 0,
             "track_total_hits": True,
             "aggs": {
                 k: {"terms": {"field": k + ".keyword", "size": 1}}
@@ -1497,85 +1493,85 @@ class SearchContext:
                     "fmu.case.uuid",
                     "class",
                     "fmu.ensemble.name",
+                    "fmu.entity.uuid",
                     "data.name",
                     "data.tagname",
                     "data.content",
                 ]
             },
         }
-        sres = self._sumo.post("/search", json=query).json()
-        if len(sres["hits"]["hits"]) == 0:
+
+    def __verify_aggregation_operation(
+        self, sres
+    ) -> Tuple[str, str, str, str]:
+        tot_hits = sres["hits"]["total"]["value"]
+        if tot_hits == 0:
             raise Exception("No matching realizations found.")
-        prototype = sres["hits"]["hits"][0]
         conflicts = [
             k
             for (k, v) in sres["aggregations"].items()
             if (
-                ("sum_other_doc_count" in v) and (v["sum_other_doc_count"] > 0)
+                ("sum_other_doc_count" in v)
+                and (v["sum_other_doc_count"] > 0)
+                or v["buckets"][0]["doc_count"] != tot_hits
             )
         ]
         if len(conflicts) > 0:
             raise Exception(f"Conflicting values for {conflicts}")
+        entityuuid = sres["aggregations"]["fmu.entity.uuid"]["buckets"][0][
+            "key"
+        ]
+        caseuuid = sres["aggregations"]["fmu.case.uuid"]["buckets"][0]["key"]
+        ensemblename = sres["aggregations"]["fmu.ensemble.name"]["buckets"][0][
+            "key"
+        ]
+        classname = sres["aggregations"]["class"]["buckets"][0]["key"]
+        return caseuuid, classname, entityuuid, ensemblename
 
-        hits = self._search_all(select=["fmu.realization.id"])
-
-        if any(
-            hit["_source"]["fmu"].get("realization") is None for hit in hits
-        ):
-            raise Exception("Selection contains non-realization data.")
-
-        uuids = [hit["_id"] for hit in hits]
-        rids = [hit["_source"]["fmu"]["realization"]["id"] for hit in hits]
-        return prototype, uuids, rids
-
-    def _aggregate(self, columns=None, operation=None) -> objects.Child:
+    def _verify_aggregation_operation(
+        self, columns, operation
+    ) -> Tuple[str, str, str, str]:
         assert (
             operation != "collection"
             or columns is not None
             and len(columns) == 1
         ), "Exactly one column required for collection aggregation."
-        prototype, uuids, rids = self.filter(
-            column=columns
-        )._verify_aggregation_operation()
+        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)
+
+    def __prepare_aggregation_spec(
+        self, caseuuid, classname, entityuuid, ensemblename, operation, columns
+    ):
         spec = {
-            "object_ids": uuids,
+            "case_uuid": caseuuid,
+            "class": classname,
+            "entity_uuid": entityuuid,
+            "ensemble_name": ensemblename,
+            "iteration_name": ensemblename,
             "operations": [operation],
         }
-        del prototype["_source"]["fmu"]["realization"]
-        del prototype["_source"]["_sumo"]
-        del prototype["_source"]["file"]
-        if "context" in prototype["_source"]["fmu"]:
-            prototype["_source"]["fmu"]["context"]["stage"] = "ensemble"
-            pass
-        prototype["_source"]["fmu"]["aggregation"] = {
-            "id": str(uuid.uuid4()),
-            "realization_ids": rids,
-            "operation": operation,
-        }
         if columns is not None:
             spec["columns"] = columns
-            cols = columns[:]
-            table_index = prototype["_source"]["data"].get("table_index")
-            if (
-                table_index is not None
-                and len(table_index) != 0
-                and table_index[0] not in cols
-            ):
-                cols.insert(0, table_index[0])
-                pass
-            prototype["_source"]["data"]["spec"]["columns"] = cols
-            pass
+        return spec
+
+    def _aggregate(self, columns=None, operation=None) -> objects.Child:
+        caseuuid, classname, entityuuid, ensemblename = (
+            self._verify_aggregation_operation(columns, operation)
+        )
+        spec = self.__prepare_aggregation_spec(
+            caseuuid, classname, entityuuid, ensemblename, operation, columns
+        )
+        spec["object_ids"] = self.uuids
         try:
             res = self._sumo.post("/aggregations", json=spec)
         except httpx.HTTPStatusError as ex:
             print(ex.response.reason_phrase)
             print(ex.response.text)
             raise ex
-        blob = BytesIO(res.content)
-        res = self._to_sumo(prototype, blob)
-        assert isinstance(res, objects.Child)
-        res._blob = blob
-        return res
+        res = self._sumo.poll(res).json()
+        return self._to_sumo(res)
 
     def aggregate(self, columns=None, operation=None) -> objects.Child:
         if len(self.hidden) > 0:
@@ -1586,103 +1582,39 @@ class SearchContext:
             )
 
     async def _verify_aggregation_operation_async(
-        self,
-    ) -> Tuple[Dict, List[str], List[int]]:
-        query = {
-            "query": self._query,
-            "size": 1,
-            "track_total_hits": True,
-            "aggs": {
-                k: {"terms": {"field": k + ".keyword", "size": 1}}
-                for k in [
-                    "fmu.case.uuid",
-                    "class",
-                    "fmu.ensemble.name",
-                    "data.name",
-                    "data.tagname",
-                    "data.content",
-                ]
-            },
-        }
-        sres = (await self._sumo.post_async("/search", json=query)).json()
-        if len(sres["hits"]["hits"]) == 0:
-            raise Exception("No matching realizations found.")
-        prototype = sres["hits"]["hits"][0]
-        conflicts = [
-            k
-            for (k, v) in sres["aggregations"].items()
-            if (
-                ("sum_other_doc_count" in v) and (v["sum_other_doc_count"] > 0)
-            )
-        ]
-        if len(conflicts) > 0:
-            raise Exception(f"Conflicting values for {conflicts}")
-
-        hits = await self._search_all_async(select=["fmu.realization.id"])
-
-        if any(
-            hit["_source"]["fmu"].get("realization") is None for hit in hits
-        ):
-            raise Exception("Selection contains non-realization data.")
-
-        uuids = [hit["_id"] for hit in hits]
-        rids = [hit["_source"]["fmu"]["realization"]["id"] for hit in hits]
-        return prototype, uuids, rids
-
-    async def _aggregate_async(
-        self, columns=None, operation=None
-    ) -> objects.Child:
+        self, columns, operation
+    ) -> Tuple[str, str, str, str]:
         assert (
             operation != "collection"
             or columns is not None
             and 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)
+
+    async def _aggregate_async(
+        self, columns=None, operation=None
+    ) -> objects.Child:
         (
-            prototype,
-            uuids,
-            rids,
-        ) = await self.filter(
-            column=columns
-        )._verify_aggregation_operation_async()
-        spec = {
-            "object_ids": uuids,
-            "operations": [operation],
-        }
-        del prototype["_source"]["fmu"]["realization"]
-        del prototype["_source"]["_sumo"]
-        del prototype["_source"]["file"]
-        if "context" in prototype["_source"]["fmu"]:
-            prototype["_source"]["fmu"]["context"]["stage"] = "ensemble"
-            pass
-        prototype["_source"]["fmu"]["aggregation"] = {
-            "id": str(uuid.uuid4()),
-            "realization_ids": rids,
-            "operation": operation,
-        }
-        if columns is not None:
-            spec["columns"] = columns
-            cols = columns[:]
-            table_index = prototype["_source"]["data"].get("table_index")
-            if (
-                table_index is not None
-                and len(table_index) != 0
-                and table_index[0] not in cols
-            ):
-                cols.insert(0, table_index[0])
-                pass
-            prototype["_source"]["data"]["spec"]["columns"] = cols
-            pass
+            caseuuid,
+            classname,
+            entityuuid,
+            ensemblename,
+        ) = await self._verify_aggregation_operation_async(columns, operation)
+        spec = self.__prepare_aggregation_spec(
+            caseuuid, classname, entityuuid, ensemblename, operation, columns
+        )
+        spec["object_ids"] = await self.uuids_async
         try:
             res = await self._sumo.post_async("/aggregations", json=spec)
         except httpx.HTTPStatusError as ex:
             print(ex.response.reason_phrase)
             print(ex.response.text)
             raise ex
-        blob = BytesIO(res.content)
-        res = self._to_sumo(prototype, blob)
-        assert isinstance(res, objects.Child)
-        res._blob = blob
-        return res
+        res = self._sumo.poll(res).json()
+        return self._to_sumo(res)
 
     async def aggregate_async(
         self, columns=None, operation=None

{fmu_sumo-2.4.3.dist-info → fmu_sumo-2.4.4.dist-info}/METADATA

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

{fmu_sumo-2.4.3.dist-info → fmu_sumo-2.4.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
 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=xLAVxNld0iPK6tqrofzfozu9ZHg4aby5Rg0HcLuAYIU,511
+fmu/sumo/explorer/_version.py,sha256=MR9avcqaQooUbRHXdvzgSvIO8lnZznuyDaeYiPpkwyo,511
 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
@@ -10,7 +10,7 @@ fmu/sumo/explorer/objects/__init__.py,sha256=72G0yfWWMTXA-oZw5GMRkrWvQqAYfadjerE
 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=a8RTE9mlNvHVdXbMMCsv6RF9PzYn4d4JnJZQONkuFKE,63840
+fmu/sumo/explorer/objects/_search_context.py,sha256=Bu4f4ksilUYs1BVaaeBmSC0It5lC0uX_CwELVpKkPAE,61700
 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
@@ -26,8 +26,8 @@ fmu/sumo/explorer/objects/realization.py,sha256=Th3zr_nT2I1HYHkBojOAKnf_RSIPc-Ti
 fmu/sumo/explorer/objects/realizations.py,sha256=4agtQFJ5pxLyWMeIzdJbkBMc8__Md-tZOj8Un4ol22c,1562
 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.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fmu_sumo-2.4.3.dist-info/METADATA,sha256=g7mAuv0jCVQ3QvmrKnOCYe26sacr3DKl66X1PCoK2LU,14781
-fmu_sumo-2.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_sumo-2.4.3.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_sumo-2.4.3.dist-info/RECORD,,
+fmu_sumo-2.4.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fmu_sumo-2.4.4.dist-info/METADATA,sha256=xzfcvUiRnEc_TZEHrsXUi41dPYH7vm8zCPdkxAR2qvc,14781
+fmu_sumo-2.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_sumo-2.4.4.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_sumo-2.4.4.dist-info/RECORD,,