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

{fmu_sumo-2.7.0 → fmu_sumo-2.8.1}/.github/workflows/run_tests.yaml

@@ -12,7 +12,7 @@ jobs:
     strategy:
       matrix:
         python-version: ["3.11", "3.12"]
-        os: [ubuntu-latest, windows-latest, macos-13]
+        os: [ubuntu-latest, windows-latest, macos-15]
         exclude:
           - os: windows-latest
             python-version: "3.11"

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

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

{fmu_sumo-2.7.0 → fmu_sumo-2.8.1}/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.7.0'
-__version_tuple__ = version_tuple = (2, 7, 0)
+__version__ = version = '2.8.1'
+__version_tuple__ = version_tuple = (2, 8, 1)
 
-__commit_id__ = commit_id = 'g748a3bb06'
+__commit_id__ = commit_id = 'g085fb1035'

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

@@ -219,6 +219,30 @@ def _build_bucket_query_simple(query, field, size):
     }
 
 
+def _build_composite_query(query, fields, size):
+    return {
+        "size": 0,
+        "query": query,
+        "aggs": {
+            "composite": {
+                "composite": {
+                    "size": size,
+                    "sources": [
+                        {k: {"terms": {"field": v}}} for k, v in fields.items()
+                    ],
+                }
+            }
+        },
+    }
+
+
+def _extract_composite_results(res):
+    aggs = res["aggregations"]["composite"]
+    after_key = aggs.get("after_key")
+    buckets = [bucket["key"] for bucket in aggs["buckets"]]
+    return buckets, after_key
+
+
 def _set_after_key(query, field, after_key):
     if after_key is not None:
         query["aggs"][field]["composite"]["after"] = after_key
@@ -432,7 +456,7 @@ class SearchContext:
             else:
                 return hits
         after = None
-        with Pit(self._sumo, "1m") as pit:
+        async with Pit(self._sumo, "1m") as pit:
             while True:
                 query = pit.stamp_query(_set_search_after(query, after))
                 res = (
@@ -1027,6 +1051,52 @@ class SearchContext:
         }
     }
 
+    def get_composite_agg(self, fields: Dict[str, str]):
+        buckets_per_batch = 1000
+        query = _build_composite_query(self._query, fields, buckets_per_batch)
+        all_buckets = []
+        after_key = None
+        with Pit(self._sumo, "1m") as pit:
+            while True:
+                query = pit.stamp_query(
+                    _set_after_key(query, "composite", after_key)
+                )
+                res = self._sumo.post("/search", json=query)
+                res = res.json()
+                pit.update_from_result(res)
+                buckets, after_key = _extract_composite_results(res)
+                if len(buckets) == 0:
+                    break
+                all_buckets = all_buckets + buckets
+                if len(buckets) < buckets_per_batch:
+                    break
+                pass
+
+        return all_buckets
+
+    async def get_composite_agg_async(self, fields: Dict[str, str]):
+        buckets_per_batch = 1000
+        query = _build_composite_query(self._query, fields, buckets_per_batch)
+        all_buckets = []
+        after_key = None
+        async with Pit(self._sumo, "1m") as pit:
+            while True:
+                query = pit.stamp_query(
+                    _set_after_key(query, "composite", after_key)
+                )
+                res = await self._sumo.post_async("/search", json=query)
+                res = res.json()
+                pit.update_from_result(res)
+                buckets, after_key = _extract_composite_results(res)
+                if len(buckets) == 0:
+                    break
+                all_buckets = all_buckets + buckets
+                if len(buckets) < buckets_per_batch:
+                    break
+                pass
+
+        return all_buckets
+
     def _context_for_class(self, cls):
         return self.filter(cls=cls)
 

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-"""Module for searchcontext for collection of ensembles."""
-
-from typing import List
-
-from ._search_context import SearchContext
-
-
-class Ensembles(SearchContext):
-    def __init__(self, sc, uuids):
-        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
-        self._hits = uuids
-        return
-
-    @property
-    def classes(self) -> List[str]:
-        return ["ensemble"]
-
-    @property
-    async def classes_async(self) -> List[str]:
-        return ["ensemble"]
-
-    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)

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

@@ -1,42 +0,0 @@
-"""Module for searchcontext for collection of realizations."""
-
-from typing import List
-
-from ._search_context import SearchContext
-
-
-class Realizations(SearchContext):
-    def __init__(self, sc, uuids):
-        super().__init__(sc._sumo, must=[{"ids": {"values": uuids}}])
-        self._hits = uuids
-        return
-
-    def _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)
-
-    @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
-        ]