fmu-sumo 2.5.0__tar.gz → 2.6.1__tar.gz

{fmu_sumo-2.5.0/src/fmu_sumo.egg-info → fmu_sumo-2.6.1}/PKG-INFO

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

{fmu_sumo-2.5.0 → fmu_sumo-2.6.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.5.0'
-__version_tuple__ = version_tuple = (2, 5, 0)
+__version__ = version = '2.6.1'
+__version_tuple__ = version_tuple = (2, 6, 1)
 
-__commit_id__ = commit_id = 'g2782fab59'
+__commit_id__ = commit_id = 'gcd5b68d28'

{fmu_sumo-2.5.0 → fmu_sumo-2.6.1}/src/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-2.5.0 → fmu_sumo-2.6.1}/src/fmu/sumo/explorer/objects/_search_context.py

@@ -929,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]:
@@ -978,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"}}],
@@ -1475,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.")
@@ -1502,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
     ) -> 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
@@ -1530,7 +1592,9 @@ 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)
         )
@@ -1544,30 +1608,85 @@ 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
     ) -> 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,
@@ -1584,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)
@@ -1623,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)
@@ -1652,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-2.5.0 → fmu_sumo-2.6.1}/src/fmu/sumo/explorer/objects/polygons.py

@@ -28,7 +28,11 @@ class Polygons(Child):
         import pandas as pd
 
         try:
-            return pd.read_csv(self.blob)
+            if self.format == "csv":
+                return pd.read_csv(self.blob)
+            if self.format == "parquet":
+                return pd.read_parquet(self.blob)
+            raise TypeError()
         except TypeError as type_err:
             raise TypeError(f"Unknown format: {self.format}") from type_err
 
@@ -42,6 +46,10 @@ class Polygons(Child):
         import pandas as pd
 
         try:
-            return pd.read_csv(await self.blob_async)
+            if self.format == "csv":
+                return pd.read_csv(await self.blob_async)
+            if self.format == "parquet":
+                return pd.read_parquet(await self.blob_async)
+            raise TypeError()
         except TypeError as type_err:
             raise TypeError(f"Unknown format: {self.format}") from type_err

{fmu_sumo-2.5.0 → fmu_sumo-2.6.1/src/fmu_sumo.egg-info}/PKG-INFO

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