fmu-sumo 2.3.8__py3-none-any.whl → 2.3.9__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.3.8'
-__version_tuple__ = version_tuple = (2, 3, 8)
+__version__ = version = '2.3.9'
+__version_tuple__ = version_tuple = (2, 3, 9)

fmu/sumo/explorer/explorer.py

@@ -7,6 +7,7 @@ import httpx
 from sumo.wrapper import SumoClient
 
 from .objects._search_context import SearchContext
+from .objects.cases import Cases
 
 
 class Explorer(SearchContext):
@@ -57,7 +58,8 @@ class Explorer(SearchContext):
 
     @property
     def cases(self):
-        return self._context_for_class("case")
+        uuids = self._context_for_class("case").uuids
+        return Cases(self, uuids)
 
     def get_permissions(self, asset: Optional[str] = None):
         """Get permissions

fmu/sumo/explorer/objects/__init__.py

@@ -10,6 +10,8 @@ from .cpgrid import CPGrid
 from .cpgrid_property import CPGridProperty
 from .cube import Cube
 from .dictionary import Dictionary
+from .ensemble import Ensemble
+from .ensembles import Ensembles
 from .iteration import Iteration
 from .iterations import Iterations
 from .polygons import Polygons

fmu/sumo/explorer/objects/_child.py

@@ -21,6 +21,33 @@ class Child(Document):
         self._sumo = sumo
         self._blob = blob
 
+    def __repr__(self):
+        if self.stage == "case" and self.__class__.__name__ != "Case":
+            return (
+                f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+                f"in case {self.casename} "
+                f"in asset {self.asset}>"
+            )
+        else:
+            if self.realization:
+                return (
+                    f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+                    f"in realization {self.realization} "
+                    f"in iteration {self.iteration} "
+                    f"in case {self.casename} "
+                    f"in asset {self.asset}>"
+                )
+            if self.operationname:
+                return (
+                    f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+                    f"in operation {self.operationname} "
+                    f"in iteration {self.iteration} "
+                    f"in case {self.casename} "
+                    f"in asset {self.asset}>"
+                )
+            else:
+                return super().__repr__()
+
     @property
     def blob(self) -> BytesIO:
         """Object blob"""
@@ -167,3 +194,13 @@ class Child(Document):
     def name(self) -> str:
         """Object data name"""
         return self.get_property("data.name")
+
+    @property
+    def asset(self) -> str:
+        """Object asset name"""
+        return self.get_property("access.asset.name")
+
+    @property
+    def operationname(self) -> str:
+        """Object aggregation operation name"""
+        return self.get_property("fmu.aggregation.operation")

fmu/sumo/explorer/objects/_document.py

@@ -1,5 +1,6 @@
 """Contains class for one document"""
 
+import json
 import re
 from typing import Any, Dict, List, Union
 
@@ -18,6 +19,15 @@ class Document:
         self._uuid = metadata["_id"]
         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}>"
+        )
+
     @property
     def uuid(self):
         """Return uuid
@@ -60,3 +70,11 @@ class Document:
     @property
     def template_path(self) -> str:
         return ""
+
+    @property
+    def name(self) -> str:
+        return "Should not happen"
+
+    @property
+    def asset(self) -> str:
+        return self.get_property("access.asset.name")

fmu/sumo/explorer/objects/_search_context.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import uuid
 import warnings
 from datetime import datetime
@@ -136,7 +137,11 @@ _filterspec = {
     "relative_path": [_gen_filter_gen, "file.relative_path.keyword"],
     "tagname": [_gen_filter_gen, "data.tagname.keyword"],
     "dataformat": [_gen_filter_gen, "data.format.keyword"],
-    "iteration": [_gen_filter_gen, "fmu.iteration.name.keyword"],
+    "iteration": [
+        _gen_filter_gen,
+        "fmu.iteration.name.keyword",
+    ],  # FIXME: to be removed
+    "ensemble": [_gen_filter_gen, "fmu.ensemble.name.keyword"],
     "realization": [_gen_filter_gen, "fmu.realization.id"],
     "aggregation": [_gen_filter_gen, "fmu.aggregation.operation.keyword"],
     "stage": [_gen_filter_gen, "fmu.context.stage.keyword"],
@@ -150,6 +155,7 @@ _filterspec = {
     "stratigraphic": [_gen_filter_bool, "data.stratigraphic"],
     "is_observation": [_gen_filter_bool, "data.is_observation"],
     "is_prediction": [_gen_filter_bool, "data.is_prediction"],
+    "standard_result": [_gen_filter_gen, "data.standard_result.name.keyword"],
     "complex": [_gen_filter_complex, None],
     "has": [_gen_filter_none, None],
 }
@@ -262,6 +268,7 @@ class SearchContext:
         self._visible = visible
         self._hidden = hidden
         self._field_values = {}
+        self._field_values_and_counts = {}
         self._hits = None
         self._cache = LRUCache(capacity=200)
         self._length = None
@@ -270,6 +277,25 @@ 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:
+            return f"<{cls}: {length} objects>"
+        else:
+            if len(self.classes) == 1:
+                return f"<{cls}: {length} objects of type {self.classes[0]}>"
+            else:
+                return f"<{cls}: {length} objects of types {self.classes}>"
+
     @property
     def _query(self):
         must = self._must[:]
@@ -303,7 +329,8 @@ class SearchContext:
             "table": objects.Table,
             "cpgrid": objects.CPGrid,
             "cpgrid_property": objects.CPGridProperty,
-            "iteration": objects.Iteration,
+            "iteration": objects.Iteration,  # FIXME: to be removed
+            "ensemble": objects.Ensemble,
             "realization": objects.Realization,
         }.get(cls)
         if constructor is None:
@@ -775,6 +802,23 @@ class SearchContext:
 
         return all_buckets
 
+    def get_field_values_and_counts(self, field: str) -> Dict[str, int]:
+        """Get List of unique values with occurrence counts for a given field
+
+        Arguments:
+            - field (str): a metadata field
+
+        Returns:
+            A mapping from unique values to count.
+        """
+        if field not in self._field_values_and_counts:
+            buckets = {
+                b["key"]: b["doc_count"] for b in self._get_buckets(field)
+            }
+            self._field_values_and_counts[field] = buckets
+
+        return self._field_values_and_counts[field]
+
     def get_field_values(self, field: str) -> List:
         """Get List of unique values for a given field
 
@@ -804,6 +848,26 @@ class SearchContext:
         """
         return self.get_field_values(field)
 
+    async def get_field_values_and_counts_async(
+        self, field: str
+    ) -> Dict[str, int]:
+        """Get List of unique values with occurrence counts for a given field
+
+        Arguments:
+            - field (str): a metadata field
+
+        Returns:
+            A mapping from unique values to count.
+        """
+        if field not in self._field_values_and_counts:
+            buckets = {
+                b["key"]: b["doc_count"]
+                for b in await self._get_buckets_async(field)
+            }
+            self._field_values_and_counts[field] = buckets
+
+        return self._field_values_and_counts[field]
+
     async def get_field_values_async(self, field: str) -> List:
         """Get List of unique values for a given field
 
@@ -886,17 +950,33 @@ class SearchContext:
         return objects.Cases(self, uuids)
 
     @property
+    @deprecation.deprecated(details="Use the method 'ensembles' instead.")
     def iterations(self):
         """Iterations from current selection."""
         uuids = self.get_field_values("fmu.iteration.uuid.keyword")
         return objects.Iterations(self, uuids)
 
     @property
+    @deprecation.deprecated(
+        details="Use the method 'ensembles_async' instead."
+    )
     async def iterations_async(self):
         """Iterations from current selection."""
         uuids = await self.get_field_values_async("fmu.iteration.uuid.keyword")
         return objects.Iterations(self, uuids)
 
+    @property
+    def ensembles(self):
+        """Ensembles from current selection."""
+        uuids = self.get_field_values("fmu.ensemble.uuid.keyword")
+        return objects.Ensembles(self, uuids)
+
+    @property
+    async def ensembles_async(self):
+        """Ensembles from current selection."""
+        uuids = await self.get_field_values_async("fmu.ensemble.uuid.keyword")
+        return objects.Ensembles(self, uuids)
+
     @property
     def realizations(self):
         """Realizations from current selection."""
@@ -1135,7 +1215,9 @@ class SearchContext:
             obj = hits[0]
             obj["_id"] = uuid
             obj["_source"]["class"] = "iteration"
-            return self._to_sumo(obj)
+            ret = self._to_sumo(obj)
+            self._cache.put(uuid, ret)
+            return ret
 
     async def get_iteration_by_uuid_async(
         self, uuid: str
@@ -1163,7 +1245,81 @@ class SearchContext:
             obj = hits[0]
             obj["_id"] = uuid
             obj["_source"]["class"] = "iteration"
-            return self._to_sumo(obj)
+            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",
+                ],
+            },
+        }
+
+    def get_ensemble_by_uuid(self, uuid: str) -> objects.Ensemble:
+        """Get ensemble object by uuid
+
+        Args:
+            uuid (str): ensemble uuid
+
+        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
+
+    async def get_ensemble_by_uuid_async(self, uuid: str) -> objects.Ensemble:
+        """Get ensemble object by uuid
+
+        Args:
+            uuid (str): ensemble uuid
+
+        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 {
@@ -1181,6 +1337,7 @@ class SearchContext:
                     "masterdata",
                     "fmu.case",
                     "fmu.iteration",
+                    "fmu.ensemble",
                     "fmu.realization",
                 ],
             },
@@ -1316,7 +1473,7 @@ class SearchContext:
                 for k in [
                     "fmu.case.uuid",
                     "class",
-                    "fmu.iteration.name",
+                    "fmu.ensemble.name",
                     "data.name",
                     "data.tagname",
                     "data.content",
@@ -1364,9 +1521,8 @@ class SearchContext:
         del prototype["_source"]["fmu"]["realization"]
         del prototype["_source"]["_sumo"]
         del prototype["_source"]["file"]
-        del prototype["_source"]["access"]
         if "context" in prototype["_source"]["fmu"]:
-            prototype["_source"]["fmu"]["context"]["stage"] = "iteration"
+            prototype["_source"]["fmu"]["context"]["stage"] = "ensemble"
             pass
         prototype["_source"]["fmu"]["aggregation"] = {
             "id": str(uuid.uuid4()),
@@ -1418,7 +1574,7 @@ class SearchContext:
                 for k in [
                     "fmu.case.uuid",
                     "class",
-                    "fmu.iteration.name",
+                    "fmu.ensemble.name",
                     "data.name",
                     "data.tagname",
                     "data.content",
@@ -1472,9 +1628,8 @@ class SearchContext:
         del prototype["_source"]["fmu"]["realization"]
         del prototype["_source"]["_sumo"]
         del prototype["_source"]["file"]
-        del prototype["_source"]["access"]
         if "context" in prototype["_source"]["fmu"]:
-            prototype["_source"]["fmu"]["context"]["stage"] = "iteration"
+            prototype["_source"]["fmu"]["context"]["stage"] = "ensemble"
             pass
         prototype["_source"]["fmu"]["aggregation"] = {
             "id": str(uuid.uuid4()),
@@ -1751,6 +1906,28 @@ class SearchContext:
         """List of unique object names."""
         return await self.get_field_values_async("data.name.keyword")
 
+    @property
+    def classes(self) -> List[str]:
+        """List of class names."""
+        return self.get_field_values("class.keyword")
+
+    @property
+    async def classes_async(self) -> List[str]:
+        """List of class names."""
+        return await self.get_field_values_async("class.keyword")
+
+    @property
+    def standard_results(self) -> List[str]:
+        """List of standard result names."""
+        return self.get_field_values("data.standard_result.name.keyword")
+
+    @property
+    async def standard_results_async(self) -> List[str]:
+        """List of standard result names."""
+        return await self.get_field_values_async(
+            "data.standard_result.name.keyword"
+        )
+
 
 def _gen_filter_doc(spec):
     fmap = {
@@ -1805,7 +1982,7 @@ Examples:
     Match one value::
 
         surfs = case.surfaces.filter(
-                    iteration="iter-0",
+                    ensemble="iter-0",
                     name="my_surface_name"
                 )
 

fmu/sumo/explorer/objects/cases.py

@@ -16,6 +16,8 @@ class Cases(SearchContext):
         return
 
     def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.uuids
-        return Cases(self, uuids)
+        sc = SearchContext(
+            self._sumo, must=[{"terms": {"fmu.case.uuid.keyword": self._hits}}]
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.case.uuid.keyword")
+        return Cases(sc, uuids)

fmu/sumo/explorer/objects/ensemble.py

@@ -0,0 +1,76 @@
+"""Module for (pseudo) ensemble class."""
+
+from typing import Dict, Optional
+
+from sumo.wrapper import SumoClient
+
+from ._document import Document
+from ._search_context import SearchContext
+
+
+class Ensemble(Document, SearchContext):
+    """Class for representing an ensemble in Sumo."""
+
+    def __init__(
+        self, sumo: SumoClient, metadata: Dict, blob: Optional[bytes] = None
+    ):
+        assert blob is None
+        Document.__init__(self, metadata)
+        SearchContext.__init__(
+            self,
+            sumo,
+            must=[{"term": {"fmu.ensemble.uuid.keyword": self.uuid}}],
+        )
+        pass
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+            f"in case {self.casename} "
+            f"in asset {self.asset}>"
+        )
+
+    @property
+    def field(self) -> str:
+        """Case field"""
+        return self.get_property("masterdata.smda.field[0].identifier")
+
+    @property
+    def asset(self) -> str:
+        """Case asset"""
+        return self.get_property("access.asset.name")
+
+    @property
+    def user(self) -> str:
+        """Name of user who uploaded ensemble."""
+        return self.get_property("fmu.case.user.id")
+
+    @property
+    def caseuuid(self) -> str:
+        """FMU case uuid"""
+        return self.get_property("fmu.case.uuid")
+
+    @property
+    def casename(self) -> str:
+        """FMU case name"""
+        return self.get_property("fmu.case.name")
+
+    @property
+    def ensembleuuid(self) -> str:
+        """FMU ensemble uuid"""
+        return self.get_property("fmu.ensemble.uuid")
+
+    @property
+    def ensemblename(self) -> str:
+        """FMU ensemble name"""
+        return self.get_property("fmu.ensemble.name")
+
+    @property
+    def name(self) -> str:
+        """FMU ensemble name"""
+        return self.get_property("fmu.ensemble.name")
+
+    @property
+    def uuid(self) -> str:
+        """FMU ensemble uuid"""
+        return self.get_property("fmu.ensemble.uuid")

fmu/sumo/explorer/objects/ensembles.py

@@ -0,0 +1,81 @@
+"""Module for searchcontext for collection of ensembles."""
+
+from typing import Dict, 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
+
+    # def __str__(self) -> str:
+    #     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) -> str:
+    #     return(f"<{self.__class__.__name__} {len(self)} objects of type ensemble>")
+
+    @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 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 = SearchContext(
+            self._sumo,
+            must=[{"terms": {"fmu.ensemble.uuid.keyword": self._hits}}],
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.iteration.uuid.keyword")
+        return Ensembles(sc, uuids)

fmu/sumo/explorer/objects/iteration.py

@@ -23,6 +23,13 @@ class Iteration(Document, SearchContext):
         )
         pass
 
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}: {self.name} {self.uuid}(uuid) "
+            f"in case {self.casename} "
+            f"in asset {self.asset}>"
+        )
+
     @property
     def field(self) -> str:
         """Case field"""
@@ -62,3 +69,8 @@ class Iteration(Document, SearchContext):
     def name(self) -> str:
         """FMU iteration name"""
         return self.get_property("fmu.iteration.name")
+
+    @property
+    def uuid(self) -> str:
+        """FMU iteration uuid"""
+        return self.get_property("fmu.iteration.uuid")

fmu/sumo/explorer/objects/iterations.py

@@ -1,6 +1,6 @@
 """Module for searchcontext for collection of iterations."""
 
-from typing import Dict
+from typing import Dict, List
 
 from ._search_context import SearchContext
 
@@ -11,6 +11,14 @@ class Iterations(SearchContext):
         self._hits = uuids
         return
 
+    @property
+    def classes(self) -> List[str]:
+        return ["iteration"]
+
+    @property
+    async def classes_async(self) -> List[str]:
+        return ["iteration"]
+
     def _maybe_prefetch(self, index):
         return
 
@@ -54,6 +62,9 @@ class Iterations(SearchContext):
         return obj
 
     def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.uuids
-        return Iterations(self, uuids)
+        sc = SearchContext(
+            self._sumo,
+            must=[{"terms": {"fmu.iteration.uuid.keyword": self._hits}}],
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.iteration.uuid.keyword")
+        return Iterations(sc, uuids)

fmu/sumo/explorer/objects/realization.py

@@ -23,6 +23,14 @@ class Realization(Document, SearchContext):
         )
         pass
 
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}: {self.realizationid} {self.uuid}(uuid) "
+            f"in iteration {self.iterationname} "
+            f"in case {self.casename} "
+            f"in asset {self.asset}>"
+        )
+
     @property
     def field(self) -> str:
         """Case field"""
@@ -72,8 +80,3 @@ class Realization(Document, SearchContext):
     def realizationid(self) -> int:
         """FMU realization id"""
         return self.get_property("fmu.realization.id")
-
-    @property
-    def name(self) -> str:
-        """FMU realization name"""
-        return self.get_property("fmu.realization.name")

fmu/sumo/explorer/objects/realizations.py

@@ -54,6 +54,9 @@ class Realizations(SearchContext):
         return obj
 
     def filter(self, **kwargs):
-        sc = super().filter(**kwargs)
-        uuids = sc.uuids
+        sc = SearchContext(
+            self._sumo,
+            must=[{"terms": {"fmu.realization.uuid.keyword": self._hits}}],
+        ).filter(**kwargs)
+        uuids = sc.get_field_values("fmu.realization.uuid.keyword")
         return Realizations(self, uuids)

{fmu_sumo-2.3.8.dist-info → fmu_sumo-2.3.9.dist-info}/METADATA

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

fmu_sumo-2.3.9.dist-info/RECORD

@@ -0,0 +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=xD7sq7tXCC-QKVs2SPi2bsTgQhH6dVLkP6dvZaxMKcA,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
+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=Cq2jmjRjJDjh0hwy_lKWhPdvkuoMqx6UoHFIcmAJ7OA,5905
+fmu/sumo/explorer/objects/_document.py,sha256=uPAkNzcOk8U4LCtXthWkm7kfU9W4HYHrrqV9HERDhe8,1835
+fmu/sumo/explorer/objects/_metrics.py,sha256=q6CSeCjiN1SjNx4G32Lod7Slnflsu3aoJIpwm_VMIhQ,3954
+fmu/sumo/explorer/objects/_search_context.py,sha256=qCejfIAnLNgGHhqvkhKK8T1JlK9GhV3rMqHpZXGz5z4,62554
+fmu/sumo/explorer/objects/case.py,sha256=fKp7X43ETLE1RaH3rMYxZiIuduRmf0JSnJ5gRoUgNPE,3813
+fmu/sumo/explorer/objects/cases.py,sha256=dxf3mEfx7mkgUyJaStbF2mWEwqEicfGvoi1MjD_t0As,658
+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=CKQ7i9LugXRC8nmmvj9WbbfwlNeixbsphi1oDGTtyPk,2230
+fmu/sumo/explorer/objects/iteration.py,sha256=ASZXjsxASEoVgbS-ZNpBNm3qKr1pPG0v7CAlFyiYOk4,2024
+fmu/sumo/explorer/objects/iterations.py,sha256=AdqNaJztbDiSYm4aL6Jrp0K8Pnmg_-tEz8Kw0RocRVY,1841
+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=t_4ACL-whAhaglIfh0m8vOsbluWSYO5I9bg0rt9erb0,1679
+fmu/sumo/explorer/objects/surface.py,sha256=zHBtjLCIfkRHBv39OeJjA9lq3puLTfTII6TndZTtxVI,1627
+fmu/sumo/explorer/objects/table.py,sha256=vLor3YTddHkDWZSMyWPQsddFNQ2_VXE_O-stmPIWIaQ,4900
+fmu_sumo-2.3.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fmu_sumo-2.3.9.dist-info/METADATA,sha256=4jJRAWxT1gJVIwUvZ60Cu633KU98N-I56Axtn6_zZdU,14780
+fmu_sumo-2.3.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+fmu_sumo-2.3.9.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_sumo-2.3.9.dist-info/RECORD,,

fmu/sumo/explorer/objects/table_aggregated.py

@@ -1,123 +0,0 @@
-"""module containing class for table"""
-
-from fmu.sumo.explorer._utils import Utils
-from fmu.sumo.explorer.objects.case import Case
-from fmu.sumo.explorer.objects.table import Table
-
-
-class AggregatedTable:
-    """Class for representing an aggregated table in Sumo"""
-
-    def __init__(
-        self,
-        case: Case,
-        name: str,
-        tag: str,
-        iteration: str,
-        aggregation: str = "collection",
-    ) -> None:
-        """Init of aggregated table
-
-        Args:
-            case (Sumo.Case): given case object
-            name (str): name of table
-            tag (str): name of tag
-            iteration (str): name of interation
-            aggregation (str, optional): aggregation type
-        """
-        self._sumo = case._sumo
-        self._utils = Utils(self._sumo)
-        self._case = case
-        self._name = name
-        self._tag = tag
-        self._iteration = iteration
-        self._aggregation = aggregation
-        self._parameters = None
-        self._collection = case.tables.filter(
-            name=name,
-            tagname=tag,
-            iteration=iteration,
-            aggregation=aggregation,
-        )
-
-    @property
-    def columns(self):
-        """Return column names
-
-        Returns:
-            list: the column names available
-        """
-        return self._collection.columns
-
-    @property
-    def parameters(self):
-        """Return parameter set for iteration
-
-        Returns:
-            dict: parameters connected to iteration
-        """
-        if not self._parameters:
-            must = self._utils.build_terms(
-                {
-                    "class.keyword": "table",
-                    "_sumo.parent_object.keyword": self._case.uuid,
-                    "data.name.keyword": self._name,
-                    "data.tagname.keyword": self._tag,
-                    "fmu.iteration.name.keyword": self._iteration,
-                    "fmu.aggregation.operation.keyword": "collection",
-                }
-            )
-
-            query = {
-                "size": 1,
-                "_source": ["fmu.iteration.parameters"],
-                "query": {"bool": {"must": must}},
-            }
-
-            res = self._sumo.post("/search", json=query)
-            doc = res.json()["hits"]["hits"][0]
-            self._parameters = doc["_source"]["fmu"]["iteration"]["parameters"]
-
-        return self._parameters
-
-    @property
-    async def parameters_async(self):
-        """Return parameter set for iteration
-
-        Returns:
-            dict: parameters connected to iteration
-        """
-        if not self._parameters:
-            must = self._utils.build_terms(
-                {
-                    "class.keyword": "table",
-                    "_sumo.parent_object.keyword": self._case.uuid,
-                    "data.name.keyword": self._name,
-                    "data.tagname.keyword": self._tag,
-                    "fmu.iteration.name.keyword": self._iteration,
-                    "fmu.aggregation.operation.keyword": "collection",
-                }
-            )
-
-            query = {
-                "size": 1,
-                "_source": ["fmu.iteration.parameters"],
-                "query": {"bool": {"must": must}},
-            }
-
-            res = await self._sumo.post_async("/search", json=query)
-            doc = res.json()["hits"]["hits"][0]
-            self._parameters = doc["_source"]["fmu"]["iteration"]["parameters"]
-
-        return self._parameters
-
-    def __len__(self):
-        return len(self._collection)
-
-    def __getitem__(self, column) -> Table:
-        try:
-            return self._collection.filter(column=column)[0]
-        except IndexError as i_ex:
-            raise IndexError(
-                f"Column: '{column}' does not exist, try again"
-            ) from i_ex

fmu_sumo-2.3.8.dist-info/RECORD

@@ -1,32 +0,0 @@
-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=3Oc3thyKkSSxKGqu1ruTNsjrUTMaCkmwZoi_w-3OL9M,511
-fmu/sumo/explorer/cache.py,sha256=uvz8TciwBnDEwJIHa9wneC0WVWuzhUqyF3dzk4kvGNk,1037
-fmu/sumo/explorer/explorer.py,sha256=pVm6hYWxXH22VslATrnWkmgVSF3OSqLDCoAA3S5FvBo,2857
-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=WKBwuUuKX7ymBU1C5GiuBBl1Taq7LJPlDe8SuZmlljk,573
-fmu/sumo/explorer/objects/_child.py,sha256=7w32fdRgFSK1rcpSrWJeX2aE0RniaTv0H57iatSKscc,4516
-fmu/sumo/explorer/objects/_document.py,sha256=ISxLRwWDO6PJRywTfFEua1_D6NgRW2PCbqifHA8ZyPo,1405
-fmu/sumo/explorer/objects/_metrics.py,sha256=q6CSeCjiN1SjNx4G32Lod7Slnflsu3aoJIpwm_VMIhQ,3954
-fmu/sumo/explorer/objects/_search_context.py,sha256=FQr79ZsLm66_1JdPEzuaqS35YWWcVL6qrOvjtgg_weM,56810
-fmu/sumo/explorer/objects/case.py,sha256=fKp7X43ETLE1RaH3rMYxZiIuduRmf0JSnJ5gRoUgNPE,3813
-fmu/sumo/explorer/objects/cases.py,sha256=_deqorrU8KjtkJAgtxOBl9Q-3_FVuxkVydul_wknerE,527
-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/iteration.py,sha256=CqdXITmClNer_Rq7JPq4TNUwgP3X4PwKQtKDXn8yyqM,1690
-fmu/sumo/explorer/objects/iterations.py,sha256=trMtJiIgbTuWiVGfECtJzzwlV_Bc-ehg5ra5lz8hKtE,1509
-fmu/sumo/explorer/objects/polygons.py,sha256=k5BKuXHsLxzhMR5KId6Fly4FNygTOcShFCCMXvhjWg4,1187
-fmu/sumo/explorer/objects/realization.py,sha256=oikKdV-rCEOVAECJiEMYpfhyYupEIbQ_JcGXJ1Je9LU,2130
-fmu/sumo/explorer/objects/realizations.py,sha256=bez1aVgvehmOZ28IyfBv0lFWroG1ZhQ0qH2nvXnRYbQ,1519
-fmu/sumo/explorer/objects/surface.py,sha256=zHBtjLCIfkRHBv39OeJjA9lq3puLTfTII6TndZTtxVI,1627
-fmu/sumo/explorer/objects/table.py,sha256=vLor3YTddHkDWZSMyWPQsddFNQ2_VXE_O-stmPIWIaQ,4900
-fmu/sumo/explorer/objects/table_aggregated.py,sha256=vq2EcR36JTcQsyCeyiMgigJMDFDQfVrlTZe2LdXrDFo,3794
-fmu_sumo-2.3.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fmu_sumo-2.3.8.dist-info/METADATA,sha256=PK2TO57uD0AWODdK3b8t9revZHVOiY3UfHozF3Ou0nw,14780
-fmu_sumo-2.3.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-fmu_sumo-2.3.8.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_sumo-2.3.8.dist-info/RECORD,,