fmu-sumo 2.4.3__tar.gz → 2.4.5__tar.gz

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/PKG-INFO

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

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/docs/explorer.rst

@@ -79,8 +79,8 @@ as a base class for certain other classes in `fmu.sumo.explorer`:
 * `Case` objects are search contexts that match objects in a specific
   case.
 
-* `Iteration` objects are search contexts that match objects in a
-  specific iteration.
+* `Ensemble` objects are search contexts that match objects in a
+  specific ensemble. (Previously `Iteration`)
 
 * `Realization` objects are search contexts that match objects in a
   specific realization.
@@ -309,7 +309,7 @@ method can be used to further refine the set of matching objects:
 
     case = sumo.get_case_by_uuid("1234567")
 
-    surfaces = case.surfaces.filter(iteration="iter-0")
+    surfaces = case.surfaces.filter(ensemble="iter-0")
 
     contents = surfaces.contents
 
@@ -341,7 +341,7 @@ are useful parameters to `.filter()`:
 * `tagname`
 * `content`
 * `dataformat`
-* `iteration`
+* `ensemble`
 * `realization`
 * `aggregation`
 * `stage`
@@ -379,7 +379,7 @@ We can get list of filter values for the following properties:
 * `contents`
 * `tagnames`
 * `dataformats`
-* `iterations`
+* `ensemble`
 * `realizations`
 * `aggregations`
 * `stages`
@@ -467,7 +467,7 @@ surfaces:
     case = explorer.get_case_by_uuid("dec73fae-bb11-41f2-be37-73ba005c4967")
 
     surface_collection: SurfaceCollection = case.surfaces.filter(
-        iteration="iter-1",
+        ensemble="iter-1",
     )
 
 
@@ -490,7 +490,7 @@ This can now be reduced to:
     case = explorer.get_case_by_uuid("dec73fae-bb11-41f2-be37-73ba005c4967")
 
     surface_collection: SurfaceCollection = case.surfaces.filter(
-        iteration="iter-1",
+        ensemble="iter-1",
     )
 
     async def main():
@@ -593,7 +593,7 @@ this is currently implemented for `surfaces` and `tables`.
     surfaces = case.surfaces.filter(
         stage="realization",
         content="depth",
-        iteration="iter-0",
+        ensemble="iter-0",
         name="Valysar Fm.",
         tagname="FACIES_Fraction_Channel"
         stratigraphic="false"
@@ -610,7 +610,7 @@ this is currently implemented for `surfaces` and `tables`.
 
 In this example we perform aggregations on all realized instance of
 the surface `Valysar Fm. (FACIES_Fraction_Channel)` in
-iteration 0. The aggregation methods return `xtgeo.RegularSurface`
+ensemble 0. The aggregation methods return `xtgeo.RegularSurface`
 objects.
 
 .. note:: The methods `.mean()`, `.min()`, etc are deprecated; the
@@ -625,7 +625,7 @@ For `table` aggregation it is also necessary to specify the columns you want:
 
     sumo = Explorer(env="dev")
     case = sumo.get_case_by_uuid("5b558daf-61c5-400a-9aa2-c602bb471a16")
-    tables = case.tables.filter(iteration="iter-0", realization=True,
+    tables = case.tables.filter(ensemble="iter-0", realization=True,
                                 tagname=summary, column="FOPT")
     agg = tables.aggregate(operation="collection", columns=["FOPT"])
     agg.to_pandas()

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/examples/explorer.ipynb

@@ -106,11 +106,11 @@
     "# Get case surfaces\n",
     "surfs = case.surfaces.filter(realization=True)\n",
     "\n",
-    "# Get available iterations\n",
-    "print(\"Iterations:\", surfs.iterations)\n",
+    "# Get available ensembles\n",
+    "print(\"Ensembles:\", surfs.ensembles)\n",
     "\n",
-    "# Filter on iteration\n",
-    "surfs = surfs.filter(iteration=\"iter-0\")\n",
+    "# Filter on ensemble\n",
+    "surfs = surfs.filter(ensemble=\"iter-0\")\n",
     "\n",
     "# Get available contents\n",
     "print(\"Contents:\", surfs.contents)\n",
@@ -151,7 +151,7 @@
     "print(\"Content:\", surf.content)\n",
     "print(\"Tagname:\", surf.tagname)\n",
     "print(\"Format:\", surf.dataformat)\n",
-    "print(\"Iteration:\", surf.iteration)\n",
+    "print(\"Ensemble:\", surf.ensemble)\n",
     "print(\"Realization:\", surf.realization)\n",
     "print(\"vertical domain:\", surf.vertical_domain)\n",
     "\n",
@@ -179,9 +179,9 @@
     "\n",
     "cubes = seismic_case.cubes\n",
     "\n",
-    "print(\"Iterations\\t\", cubes.iterations)\n",
+    "print(\"Ensembles\\t\", cubes.ensembles)\n",
     "\n",
-    "cubes.filter(iteration=\"iter-0\")\n",
+    "cubes.filter(ensemble=\"iter-0\")\n",
     "\n",
     "print(\"Names:\\t\\t\", cubes.names)\n",
     "\n",
@@ -200,7 +200,7 @@
     "print(\"ID:\", cube.uuid)\n",
     "print(\"Name:\", cube.name)\n",
     "print(\"Tagname:\", cube.tagname)\n",
-    "print(\"Iteration:\", cube.iteration)\n",
+    "print(\"Ensemble:\", cube.ensemble)\n",
     "print(\"Realization:\", cube.realization)\n",
     "print(\"is_observation:\", cube[\"data\"][\"is_observation\"])\n",
     "print(\"is_prediction:\", cube[\"data\"][\"is_prediction\"])\n",
@@ -232,7 +232,9 @@
    "source": [
     "# Perform aggregation on SurfaceCollection\n",
     "\n",
-    "regsurf = surfs.min()  # .max(), .mean(), .std(), .p10(), .p90(), .p50()\n",
+    "regsurf = surfs.aggregate(\n",
+    "    operation=\"min\"\n",
+    ")  # operations: max, mean, std, p10, p90, p50\n",
     "regsurf.to_regular_surface().quickplot()"
    ]
   },

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/examples/explorer2.ipynb

@@ -21,10 +21,10 @@
    "outputs": [],
    "source": [
     "env = \"dev\"\n",
-    "caseuuid = \"d872b3ce-0322-4357-b192-32bde70d7dac\"\n",
+    "caseuuid = \"1abbf342-8460-45d7-afa6-814eac9dc9d3\"\n",
     "name = \"DROGON\"\n",
     "tagname = \"summary\"\n",
-    "iteration = \"iter-0\""
+    "ensemble = \"iter-0\""
    ]
   },
   {
@@ -35,39 +35,38 @@
    "outputs": [],
    "source": [
     "exp = Explorer(env=env)\n",
-    "len(exp.cases)"
+    "exp.cases"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "c5ecded7-bdaf-4c7e-814f-6cec002ef895",
+   "id": "9a4fa479-ed06-406f-8cdf-e3392c7453ea",
    "metadata": {},
    "outputs": [],
    "source": [
-    "exp.cases"
+    "[(case.name, case.uuid) for case in exp.cases]"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "9a4fa479-ed06-406f-8cdf-e3392c7453ea",
+   "id": "b4c047ae-4b00-48c8-a148-e425aea81928",
    "metadata": {},
    "outputs": [],
    "source": [
-    "[(case.name, case.uuid) for case in exp.cases]"
+    "case = exp.get_object(caseuuid)\n",
+    "case"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "b4c047ae-4b00-48c8-a148-e425aea81928",
+   "id": "cb418b43",
    "metadata": {},
    "outputs": [],
    "source": [
-    "case = exp.get_object(caseuuid)\n",
-    "print(f\"Case name: {case.name}\")\n",
-    "print(f\"Case UUID: {case.uuid}\")"
+    "case.overview"
    ]
   },
   {
@@ -81,7 +80,7 @@
     "    cls=\"table\",\n",
     "    name=name,\n",
     "    tagname=tagname,\n",
-    "    iteration=iteration,\n",
+    "    ensemble=ensemble,\n",
     "    realization=True,\n",
     ")\n",
     "print(f\"Number of realizations: {len(realizations)}\")\n",
@@ -153,9 +152,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "realizations = case.filter(\n",
-    "    cls=\"surface\", iteration=iteration, realization=True\n",
-    ")\n",
+    "realizations = case.filter(cls=\"surface\", ensemble=ensemble, realization=True)\n",
     "print(f\"Number of realizations: {len(realizations)}\")\n",
     "print(realizations.names)\n",
     "print(realizations.tagnames)\n",
@@ -170,7 +167,7 @@
    "outputs": [],
    "source": [
     "surfaces = realizations.filter(\n",
-    "    name=\"Valysar Fm.\", content=\"depth\", tagname=\"apstrend_aps_Channel_Average\"\n",
+    "    name=\"Valysar Fm.\", content=\"depth\", tagname=\"probcube_aps_Channel_Average\"\n",
     ")\n",
     "print(len(surfaces))\n",
     "print(surfaces.tagnames)\n",
@@ -259,7 +256,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(case.iterations)"
+    "len(case.ensembles)\n",
+    "print(case.ensembles)"
    ]
   },
   {
@@ -269,7 +267,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "iteration = exp.get_iteration_by_uuid(\"23c63921-b54c-449d-49a3-c08332faf7cc\")"
+    "ensemble = exp.get_ensemble_by_uuid(\"4e2f012d-15a4-fd57-2368-a349ff2e56a0\")"
    ]
   },
   {
@@ -279,7 +277,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration)"
+    "len(ensemble)"
    ]
   },
   {
@@ -289,7 +287,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "iteration._get_field_values(\"class.keyword\")"
+    "ensemble.get_field_values(\"class.keyword\")"
    ]
   },
   {
@@ -299,7 +297,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.cases)"
+    "ensemble.cases"
    ]
   },
   {
@@ -309,7 +307,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.realizations)"
+    "ensemble.realizations"
    ]
   },
   {
@@ -319,7 +317,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.filter(realization=13))"
+    "ensemble.filter(realization=13)"
    ]
   },
   {
@@ -329,7 +327,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.filter(realization=159))"
+    "ensemble.filter(realization=79)"
    ]
   },
   {
@@ -339,7 +337,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.filter(realization=160))"
+    "ensemble.filter(realization=100)"
    ]
   },
   {
@@ -349,7 +347,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "iteration.aggregations"
+    "ensemble.aggregations"
    ]
   },
   {
@@ -359,7 +357,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.filter(aggregation=True))"
+    "ensemble.filter(aggregation=True)"
    ]
   },
   {
@@ -369,7 +367,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(iteration.filter(realization=True))"
+    "ensemble.filter(realization=True)"
    ]
   },
   {
@@ -399,9 +397,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from fmu.sumo.explorer import filters\n",
+    "from fmu.sumo.explorer.filters import Filters\n",
     "\n",
-    "len(exp.cases.filter(has=filters.seismic4d))"
+    "exp.cases.filter(has=Filters.seismic4d)"
    ]
   },
   {
@@ -411,7 +409,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(exp.filter(has=filters.seismic4d))"
+    "exp.filter(has=Filters.seismic4d)"
    ]
   },
   {
@@ -421,7 +419,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "[case.name for case in list(exp.filter(has=filters.seismic4d).cases)[:10]]"
+    "[case.name for case in list(exp.filter(has=Filters.seismic4d).cases)[:10]]"
    ]
   },
   {
@@ -431,7 +429,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "myrealization = iteration.realizations.filter(\n",
+    "myrealization = ensemble.realizations.filter(\n",
     "    complex={\"term\": {\"fmu.realization.id\": 0}}\n",
     ")[0]\n",
     "myrealization"
@@ -454,7 +452,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(json.dumps(iteration.metadata, indent=2))"
+    "print(json.dumps(ensemble.metadata, indent=2))"
    ]
   },
   {

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/examples/grids-and-properties.ipynb

@@ -105,7 +105,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "grids[0].iteration, grids[0].realization"
+    "grids[0].ensemble, grids[0].realization"
    ]
   },
   {
@@ -115,7 +115,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "{g.iteration for g in grids}"
+    "{g.ensemble for g in grids}"
    ]
   },
   {
@@ -167,9 +167,7 @@
    "outputs": [],
    "source": [
     "with Timer():\n",
-    "    print(\n",
-    "        set(grprops._get_field_values(\"data.geometry.relative_path.keyword\"))\n",
-    "    )"
+    "    print(set(grprops.get_field_values(\"data.geometry.relative_path.keyword\")))"
    ]
   },
   {
@@ -220,7 +218,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "len(gridproperties)"
+    "gridproperties"
    ]
   },
   {

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/examples/table-aggregation.ipynb

@@ -80,20 +80,26 @@
     "    print(agg.to_pandas().sort_values(by=[\"REAL\", \"DATE\"]))\n",
     "\n",
     "\n",
-    "def run_exp(caseuuid, itername, tagname, columns):\n",
+    "def run_exp(caseuuid, ensemblename, tagname, columns):\n",
     "    case = exp.get_case_by_uuid(caseuuid)\n",
     "    print(f\"{case.asset}; {case.name}; {caseuuid}; {case.status}\")\n",
     "    rels = case.tables.visible.filter(\n",
-    "        iteration=itername, realization=True, tagname=tagname, column=columns\n",
+    "        ensemble=ensemblename,\n",
+    "        realization=True,\n",
+    "        tagname=tagname,\n",
+    "        column=columns,\n",
     "    )\n",
     "    do_aggregate(\"Full-sized tables\", tagname, rels, columns)\n",
     "    rels = case.tables.hidden.filter(\n",
-    "        iteration=itername, realization=True, tagname=tagname, column=columns\n",
+    "        ensemble=ensemblename,\n",
+    "        realization=True,\n",
+    "        tagname=tagname,\n",
+    "        column=columns,\n",
     "    )\n",
     "    do_aggregate(\"Split tables\", tagname, rels, columns)\n",
     "    with Timer(\"Fetch single-vector table\"):\n",
     "        aggs = case.tables.filter(\n",
-    "            iteration=itername,\n",
+    "            ensemble=ensemblename,\n",
     "            aggregation=True,\n",
     "            tagname=tagname,\n",
     "            column=columns[0],\n",
@@ -157,7 +163,7 @@
    "outputs": [],
    "source": [
     "caseuuid = \"8ffeb5f8-ca60-42ee-998e-53d34e47d3e2\"\n",
-    "iteration = \"iter-0\"\n",
+    "ensemble = \"iter-0\"\n",
     "case = exp.get_case_by_uuid(caseuuid)\n",
     "hidden = case.tables.hidden\n",
     "cols_f0 = hidden.filter(complex={\"term\": {\"_sumo.fragment\": 0}}).columns\n",
@@ -200,16 +206,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "run_exp(caseuuid, iteration, \"summary\", some_f0)"
+    "run_exp(caseuuid, ensemble, \"summary\", some_f0)"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "379ec147-876e-444b-b62c-1597459905d5",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/examples/tables.ipynb

@@ -122,9 +122,9 @@
    "metadata": {},
    "source": [
     "Most tables are stored during the running of an fmu run. So you will in that case have one version per realization (i.e per file path realization-n/iter-m) <br>\n",
-    "This means that it will be a slow process to get to results from one ensemble, meaning one iteration. <br>\n",
+    "This means that it will be a slow process to get to results from one ensemble. <br>\n",
     "Below is an example of how to fetch one table. General syntax: <br>\n",
-    "``table_collection = case.tables.filter(realization=<realization number>, iteration=<iteration name>,``<br>\n",
+    "``table_collection = case.tables.filter(realization=<realization number>, ensemble=<ensemble name>,``<br>\n",
     "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;``name=<table name>, tagname=<name of tag>)``<br>\n",
     "Any of the input arguements are optional, so you could end up with more than one resulting table, and in theory even if you have <br>\n",
     "used all arguements you could end up with several (long story, please ask). But you can check how many tables you have with using <br>\n",
@@ -144,7 +144,7 @@
    "source": [
     "# Filter using the key\n",
     "one_table = tables.filter(\n",
-    "    realization=0, iteration=\"iter-0\", name=\"DROGON\", tagname=\"compdat\"\n",
+    "    realization=0, ensemble=\"iter-0\", name=\"DROGON\", tagname=\"compdat\"\n",
     ")[0]\n",
     "\n",
     "# Give back the name and tag\n",
@@ -207,7 +207,7 @@
    "outputs": [],
    "source": [
     "sim_tables = tables.filter(\n",
-    "    name=\"DROGON\", iteration=\"iter-0\", aggregation=\"collection\"\n",
+    "    name=\"DROGON\", ensemble=\"iter-0\", aggregation=\"collection\"\n",
     ")\n",
     "sim_tables.tagnames"
    ]
@@ -325,7 +325,7 @@
     "\n",
     "Here ``<DATATYPE>`` can be of collection, index, mean, min, max, p10 or p90\n",
     "\n",
-    "This class gives you the aggregated tables that share name and tagname for one iteration as one object, <br> \n",
+    "This class gives you the aggregated tables that share name and tagname for one ensemble as one object, <br> \n",
     "so you don't need to know that what you are dealing with is a collection of objects\n"
    ]
   },
@@ -463,7 +463,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "COMPDAT = AggregatedTable(case, \"DROGON\", \"compdat\", iteration=\"iter-0\")\n",
+    "COMPDAT = AggregatedTable(case, \"DROGON\", \"compdat\", ensemble=\"iter-0\")\n",
     "COMPDAT[\"KH\"].to_pandas()"
    ]
   },

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/src/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.5'
+__version_tuple__ = version_tuple = (2, 4, 5)

{fmu_sumo-2.4.3 → fmu_sumo-2.4.5}/src/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
@@ -1164,6 +1162,46 @@ class SearchContext:
     def grid_properties(self) -> SearchContext:
         return self._context_for_class("cpgrid_property")
 
+    @property
+    def parameters(self) -> SearchContext:
+        return self.filter(
+            complex={
+                "bool": {
+                    "must": [
+                        {"term": {"data.name.keyword": "parameters"}},
+                        {"term": {"data.content.keyword": "parameters"}},
+                    ],
+                    "should": [
+                        {
+                            "bool": {
+                                "must": [
+                                    {"term": {"class.keyword": "dictionary"}},
+                                    {
+                                        "exists": {
+                                            "field": "fmu.realization.id"
+                                        }
+                                    },
+                                ]
+                            }
+                        },
+                        {
+                            "bool": {
+                                "must": [
+                                    {"term": {"class.keyword": "table"}},
+                                    {
+                                        "exists": {
+                                            "field": "fmu.aggregation.operation"
+                                        }
+                                    },
+                                ]
+                            }
+                        },
+                    ],
+                    "minimum_should_match": 1,
+                }
+            }
+        )
+
     def _get_object_by_class_and_uuid(self, cls, uuid) -> Any:
         obj = self.get_object(uuid)
         if obj.metadata["class"] != cls:
@@ -1484,12 +1522,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 +1533,83 @@ 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 _verify_aggregation_operation(
+        self, columns, operation
+    ) -> 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)
 
-    def _aggregate(self, columns=None, operation=None) -> objects.Child:
-        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()
+    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 +1620,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 → fmu_sumo-2.4.5}/src/fmu_sumo.egg-info/PKG-INFO

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