fmu-sumo 2.3.4__py3-none-any.whl → 2.3.6__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.4'
-__version_tuple__ = version_tuple = (2, 3, 4)
+__version__ = version = '2.3.6'
+__version_tuple__ = version_tuple = (2, 3, 6)

fmu/sumo/explorer/objects/_child.py

@@ -1,39 +1,12 @@
 """module containing class for child object"""
 
 from io import BytesIO
-from typing import Dict
+from typing import Dict, List
 
 from sumo.wrapper import SumoClient
 
 from fmu.sumo.explorer.objects._document import Document
 
-_prop_desc = [
-    ("name", "data.name", "Object name"),
-    ("dataname", "data.name", "Object name"),
-    ("classname", "class.name", "Object class name"),
-    ("casename", "fmu.case.name", "Object case name"),
-    ("caseuuid", "fmu.case.uuid", "Object case uuid"),
-    ("content", "data.content", "Content"),
-    ("tagname", "data.tagname", "Object tagname"),
-    ("columns", "data.spec.columns", "Object table columns"),
-    ("stratigraphic", "data.stratigraphic", "Object stratigraphic"),
-    ("vertical_domain", "data.vertical_domain", "Object vertical domain"),
-    ("context", "fmu.context.stage", "Object context"),
-    ("iteration", "fmu.iteration.name", "Object iteration"),
-    ("realization", "fmu.realization.id", "Object realization"),
-    (
-        "aggregation",
-        "fmu.aggregation.operation",
-        "Object aggregation operation",
-    ),
-    ("stage", "fmu.context.stage", "Object stage"),
-    ("format", "data.format", "Object file format"),
-    ("dataformat", "data.format", "Object file format"),
-    ("relative_path", "file.relative_path", "Object relative file path"),
-    ("bbox", "data.bbox", "Object boundary-box data"),
-    ("spec", "data.spec", "Object spec data"),
-]
-
 
 class Child(Document):
     """Class representing a child object in Sumo"""
@@ -95,5 +68,102 @@ class Child(Document):
             + self.relative_path.split("/")[2:]
         )
 
+    @property
+    def spec(self) -> Dict:
+        """Object spec data"""
+        return self.get_property("data.spec")
+
+    @property
+    def bbox(self) -> Dict:
+        """Object boundary-box data"""
+        return self.get_property("data.bbox")
+
+    @property
+    def relative_path(self) -> str:
+        """Object relative file path"""
+        return self.get_property("file.relative_path")
+
+    @property
+    def dataformat(self) -> str:
+        """Object file format"""
+        return self.get_property("data.format")
+
+    @property
+    def format(self) -> str:
+        """Object file format"""
+        return self.get_property("data.format")
+
+    @property
+    def stage(self) -> str:
+        """Object stage"""
+        return self.get_property("fmu.context.stage")
+
+    @property
+    def aggregation(self) -> str:
+        """Object aggregation operation"""
+        return self.get_property("fmu.aggregation.operation")
+
+    @property
+    def realization(self) -> str:
+        """Object realization"""
+        return self.get_property("fmu.realization.id")
+
+    @property
+    def iteration(self) -> str:
+        """Object iteration"""
+        return self.get_property("fmu.iteration.name")
+
+    @property
+    def context(self) -> str:
+        """Object context"""
+        return self.get_property("fmu.context.stage")
 
-Child.map_properties(Child, _prop_desc)
+    @property
+    def vertical_domain(self) -> str:
+        """Object vertical domain"""
+        return self.get_property("data.vertical_domain")
+
+    @property
+    def stratigraphic(self) -> str:
+        """Object stratigraphic"""
+        return self.get_property("data.stratigraphic")
+
+    @property
+    def columns(self) -> List[str]:
+        """Object table columns"""
+        return self.get_property("data.spec.columns")
+
+    @property
+    def tagname(self) -> str:
+        """Object tagname"""
+        return self.get_property("data.tagname")
+
+    @property
+    def content(self) -> str:
+        """Content"""
+        return self.get_property("data.content")
+
+    @property
+    def caseuuid(self) -> str:
+        """Object case uuid"""
+        return self.get_property("fmu.case.uuid")
+
+    @property
+    def casename(self) -> str:
+        """Object case name"""
+        return self.get_property("fmu.case.name")
+
+    @property
+    def classname(self) -> str:
+        """Object class name"""
+        return self.get_property("class.name")
+
+    @property
+    def dataname(self) -> str:
+        """Object data name"""
+        return self.get_property("data.name")
+
+    @property
+    def name(self) -> str:
+        """Object data name"""
+        return self.get_property("data.name")

fmu/sumo/explorer/objects/_document.py

@@ -1,7 +1,7 @@
 """Contains class for one document"""
 
 import re
-from typing import Dict, List
+from typing import Any, Dict, List, Union
 
 _path_split_rx = re.compile(r"\]\.|\.|\[")
 
@@ -11,11 +11,6 @@ def _splitpath(path):
     return [int(x) if re.match(r"\d+", x) else x for x in parts]
 
 
-def _makeprop(attribute):
-    path = _splitpath(attribute)
-    return lambda self: self._get_property(path)
-
-
 class Document:
     """Class for representing a document in Sumo"""
 
@@ -41,7 +36,7 @@ class Document:
         """
         return self._metadata
 
-    def _get_property(self, path: List[str]):
+    def _get_property(self, path: List[Union[str, int]]):
         curr = self._metadata
 
         for key in path:
@@ -52,10 +47,8 @@ class Document:
 
         return curr
 
+    def get_property(self, path: str) -> Any:
+        return self._get_property(_splitpath(path))
+
     def __getitem__(self, key: str):
         return self._metadata[key]
-
-    @staticmethod
-    def map_properties(cls, propmap):
-        for name, attribute, doc in propmap:
-            setattr(cls, name, property(_makeprop(attribute), None, None, doc))

fmu/sumo/explorer/objects/_search_context.py

@@ -162,45 +162,6 @@ def _gen_filters(spec):
 filters = _gen_filters(_filterspec)
 
 
-_bucket_spec = {
-    "names": ["data.name.keyword", "List of unique object names."],
-    "tagnames": ["data.tagname.keyword", "List of unique object tagnames."],
-    "dataformats": [
-        "data.format.keyword",
-        "List of unique data.format values.",
-    ],
-    "aggregations": [
-        "fmu.aggregation.operation.keyword",
-        "List of unique object aggregation operations.",
-    ],
-    "stages": ["fmu.context.stage.keyword", "List of unique stages."],
-    # "stratigraphic": [
-    #     "data.stratigraphic",
-    #     "List of unique object stratigraphic.",
-    # ],
-    "vertical_domains": [
-        "data.vertical_domain",
-        "List of unique object vertical domains.",
-    ],
-    "contents": ["data.content.keyword", "List of unique contents."],
-    "columns": ["data.spec.columns.keyword", "List of unique column names."],
-    "statuses": ["_sumo.status.keyword", "List of unique case statuses."],
-    "users": ["fmu.case.user.id.keyword", "List of unique user names."],
-    "fieldidentifiers": [
-        "masterdata.smda.field.identifier.keyword",
-        "List of unique field names.",
-    ],
-    "stratcolumnidentifiers": [
-        "masterdata.smda.stratigraphic_column.identifier.keyword",
-        "List of unique stratigraphic column names.",
-    ],
-    "realizationids": [
-        "fmu.realization.id",
-        "List of unique realization ids.",
-    ],
-}
-
-
 def _build_bucket_query(query, field, size):
     return {
         "size": 0,
@@ -500,6 +461,22 @@ class SearchContext:
         uuid = self._hits[index]
         return await self.get_object_async(uuid)
 
+    @property
+    def single(self):
+        """Verifies that SearchContext contains exactly one object,
+        and returns it.
+        """
+        assert len(self) == 1
+        return self[0]
+
+    @property
+    async def single_async(self):
+        """Verifies that SearchContext contains exactly one object,
+        and returns it.
+        """
+        assert await self.length_async() == 1
+        return await self.getitem_async(0)
+
     def select(self, sel):
         """Specify what should be returned from elasticsearch.
         Has the side effect of clearing the lru cache.
@@ -1531,6 +1508,146 @@ class SearchContext:
     def p90(self):
         return self.aggregate(operation="p90")
 
+    @property
+    def realizationids(self) -> List[int]:
+        """List of unique realization ids."""
+        return self.get_field_values("fmu.realization.id")
+
+    @property
+    async def realizationids_async(self) -> List[int]:
+        """List of unique realization ids."""
+        return await self.get_field_values_async("fmu.realization.id")
+
+    @property
+    def stratcolumnidentifiers(self) -> List[str]:
+        """List of unique stratigraphic column names."""
+        return self.get_field_values(
+            "masterdata.smda.stratigraphic_column.identifier.keyword"
+        )
+
+    @property
+    async def stratcolumnidentifiers_async(self) -> List[str]:
+        """List of unique stratigraphic column names."""
+        return await self.get_field_values_async(
+            "masterdata.smda.stratigraphic_column.identifier.keyword"
+        )
+
+    @property
+    def fieldidentifiers(self) -> List[str]:
+        """List of unique field names."""
+        return self.get_field_values(
+            "masterdata.smda.field.identifier.keyword"
+        )
+
+    @property
+    async def fieldidentifiers_async(self) -> List[str]:
+        """List of unique field names."""
+        return await self.get_field_values_async(
+            "masterdata.smda.field.identifier.keyword"
+        )
+
+    @property
+    def users(self) -> List[str]:
+        """List of unique user names."""
+        return self.get_field_values("fmu.case.user.id.keyword")
+
+    @property
+    async def users_async(self) -> List[str]:
+        """List of unique user names."""
+        return await self.get_field_values_async("fmu.case.user.id.keyword")
+
+    @property
+    def statuses(self) -> List[str]:
+        """List of unique case statuses."""
+        return self.get_field_values("_sumo.status.keyword")
+
+    @property
+    async def statuses_async(self) -> List[str]:
+        """List of unique case statuses."""
+        return await self.get_field_values_async("_sumo.status.keyword")
+
+    @property
+    def columns(self) -> List[str]:
+        """List of unique column names."""
+        return self.get_field_values("data.spec.columns.keyword")
+
+    @property
+    async def columns_async(self) -> List[str]:
+        """List of unique column names."""
+        return await self.get_field_values_async("data.spec.columns.keyword")
+
+    @property
+    def contents(self) -> List[str]:
+        """List of unique contents."""
+        return self.get_field_values("data.content.keyword")
+
+    @property
+    async def contents_async(self) -> List[str]:
+        """List of unique contents."""
+        return await self.get_field_values_async("data.content.keyword")
+
+    @property
+    def vertical_domains(self) -> List[str]:
+        """List of unique object vertical domains."""
+        return self.get_field_values("data.vertical_domain")
+
+    @property
+    async def vertical_domains_async(self) -> List[str]:
+        """List of unique object vertical domains."""
+        return await self.get_field_values_async("data.vertical_domain")
+
+    @property
+    def stages(self) -> List[str]:
+        """List of unique stages."""
+        return self.get_field_values("fmu.context.stage.keyword")
+
+    @property
+    async def stages_async(self) -> List[str]:
+        """List of unique stages."""
+        return await self.get_field_values_async("fmu.context.stage.keyword")
+
+    @property
+    def aggregations(self) -> List[str]:
+        """List of unique object aggregation operations."""
+        return self.get_field_values("fmu.aggregation.operation.keyword")
+
+    @property
+    async def aggregations_async(self) -> List[str]:
+        """List of unique object aggregation operations."""
+        return await self.get_field_values_async(
+            "fmu.aggregation.operation.keyword"
+        )
+
+    @property
+    def dataformats(self) -> List[str]:
+        """List of unique data.format values."""
+        return self.get_field_values("data.format.keyword")
+
+    @property
+    async def dataformats_async(self) -> List[str]:
+        """List of unique data.format values."""
+        return await self.get_field_values_async("data.format.keyword")
+
+    @property
+    def tagnames(self) -> List[str]:
+        """List of unique object tagnames."""
+        return self.get_field_values("data.tagname.keyword")
+
+    @property
+    async def tagnames_async(self) -> List[str]:
+        """List of unique object tagnames."""
+        return await self.get_field_values_async("data.tagname.keyword")
+
+    @property
+    def names(self) -> List[str]:
+        """List of unique object names."""
+        return self.get_field_values("data.name.keyword")
+
+    @property
+    async def names_async(self) -> List[str]:
+        """List of unique object names."""
+        return await self.get_field_values_async("data.name.keyword")
+
 
 def _gen_filter_doc(spec):
     fmap = {
@@ -1619,35 +1736,3 @@ Examples:
 
 
 SearchContext.filter.__doc__ = _gen_filter_doc(_filterspec)
-
-
-def _build_bucket_fn(property, docstring):
-    def fn(self):
-        return self.get_field_values(property)
-
-    return fn
-
-
-def _build_bucket_fn_async(property, docstring):
-    async def fn(self):
-        return await self.get_field_values_async(property)
-
-    return fn
-
-
-def _inject_bucket_fns(spec):
-    for name, defn in spec.items():
-        prop, docstring = defn
-        fn = _build_bucket_fn(prop, docstring)
-        setattr(SearchContext, name, property(fn, None, None, docstring))
-        afn = _build_bucket_fn_async(prop, docstring)
-        setattr(
-            SearchContext,
-            name + "_async",
-            property(afn, None, None, docstring),
-        )
-        pass
-    return
-
-
-_inject_bucket_fns(_bucket_spec)

fmu/sumo/explorer/objects/case.py

@@ -7,14 +7,6 @@ from sumo.wrapper import SumoClient
 from fmu.sumo.explorer.objects._document import Document
 from fmu.sumo.explorer.objects._search_context import SearchContext
 
-_prop_desc = [
-    ("name", "fmu.case.name", "Case name"),
-    ("status", "_sumo.status", "Case status"),
-    ("user", "fmu.case.user.id", "Name of user who uploaded case."),
-    ("asset", "access.asset.name", "Case asset"),
-    ("field", "masterdata.smda.field[0].identifier", "Case field"),
-]
-
 
 def _make_overview_query(id):
     return {
@@ -96,5 +88,27 @@ class Case(Document, SearchContext):
 
         return self._overview
 
+    @property
+    def field(self) -> str:
+        """Case field"""
+        return self.get_property("masterdata.smda.field[0].identifier")
 
-Case.map_properties(Case, _prop_desc)
+    @property
+    def asset(self) -> str:
+        """Case asset"""
+        return self.get_property("access.asset.name")
+
+    @property
+    def user(self) -> str:
+        """Name of user who uploaded case."""
+        return self.get_property("fmu.case.user.id")
+
+    @property
+    def status(self) -> str:
+        """Case status"""
+        return self.get_property("_sumo.status")
+
+    @property
+    def name(self) -> str:
+        """Case name"""
+        return self.get_property("fmu.case.name")

fmu/sumo/explorer/objects/iteration.py

@@ -7,15 +7,6 @@ from sumo.wrapper import SumoClient
 from fmu.sumo.explorer.objects._document import Document
 from fmu.sumo.explorer.objects._search_context import SearchContext
 
-_prop_desc = [
-    ("name", "fmu.iteration.name", "FMU iteration name"),
-    ("casename", "fmu.case.name", "FMU case name"),
-    ("caseuuid", "fmu.case.uuid", "FMU case uuid"),
-    ("user", "fmu.case.user.id", "Name of user who uploaded iteration."),
-    ("asset", "access.asset.name", "Case asset"),
-    ("field", "masterdata.smda.field[0].identifier", "Case field"),
-]
-
 
 class Iteration(Document, SearchContext):
     """Class for representing an iteration in Sumo."""
@@ -27,6 +18,34 @@ class Iteration(Document, SearchContext):
             sumo,
             must=[{"term": {"fmu.iteration.uuid.keyword": self.uuid}}],
         )
-
-
-Iteration.map_properties(Iteration, _prop_desc)
+        pass
+
+    @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 iteration."""
+        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 name(self) -> str:
+        """FMU iteration name"""
+        return self.get_property("fmu.iteration.name")

fmu/sumo/explorer/objects/realization.py

@@ -7,16 +7,6 @@ from sumo.wrapper import SumoClient
 from fmu.sumo.explorer.objects._document import Document
 from fmu.sumo.explorer.objects._search_context import SearchContext
 
-_prop_desc = [
-    ("iterationname", "fmu.iteration.name", "FMU iteration name"),
-    ("iterationuuid", "fmu.iteration.uuid", "FMU iteration uuid"),
-    ("casename", "fmu.case.name", "FMU case name"),
-    ("caseuuid", "fmu.case.uuid", "FMU case uuid"),
-    ("user", "fmu.case.user.id", "Name of user who uploaded iteration."),
-    ("asset", "access.asset.name", "Case asset"),
-    ("field", "masterdata.smda.field[0].identifier", "Case field"),
-]
-
 
 class Realization(Document, SearchContext):
     """Class for representing a realization in Sumo."""
@@ -28,6 +18,39 @@ class Realization(Document, SearchContext):
             sumo,
             must=[{"term": {"fmu.realization.uuid.keyword": self.uuid}}],
         )
-
-
-Realization.map_properties(Realization, _prop_desc)
+        pass
+
+    @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 iteration."""
+        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 iterationuuid(self) -> str:
+        """FMU iteration uuid"""
+        return self.get_property("fmu.iteration.uuid")
+
+    @property
+    def iterationname(self) -> str:
+        """FMU iteration name"""
+        return self.get_property("fmu.iteration.name")

{fmu_sumo-2.3.4.dist-info → fmu_sumo-2.3.6.dist-info}/METADATA

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

{fmu_sumo-2.3.4.dist-info → fmu_sumo-2.3.6.dist-info}/RECORD

@@ -1,32 +1,32 @@
 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=uwWN-nUjSdzfl2KBdAxl_KFIRtDM-6vnPwbujKx_J2g,511
+fmu/sumo/explorer/_version.py,sha256=vyHreFbi5FOhiaz30HIVL3nIoqJd89y5l-gC9UA3AqA,511
 fmu/sumo/explorer/cache.py,sha256=uvz8TciwBnDEwJIHa9wneC0WVWuzhUqyF3dzk4kvGNk,1037
 fmu/sumo/explorer/explorer.py,sha256=0dSUGG2-4yOYGXRWC5Ubrdjd-hIEEgRxJlMvvIAYom0,2806
 fmu/sumo/explorer/filters.py,sha256=NVTWbjL-dIHQZeWcR3Orgx6f0WHPpThSPxmxZo5tvfM,812
 fmu/sumo/explorer/timefilter.py,sha256=GetbPm0VYVSts_G7F2BA2nvgvvKzWE26ZjhqRc1avIE,6212
 fmu/sumo/explorer/objects/__init__.py,sha256=2XqF0abZI1T7I_Fjlhvs4_vjwid_3HUsqdxmA6nNcLo,941
-fmu/sumo/explorer/objects/_child.py,sha256=12qVVsTHg8Z_2SAxXpdIpQGwgeOiOKxWzPMCGZ3ZEtM,3104
-fmu/sumo/explorer/objects/_document.py,sha256=wgRA18_68RxMFoQly4UowVIOrZqETithms9zZrqXTLw,1418
+fmu/sumo/explorer/objects/_child.py,sha256=ase6ZypK2KB-Zv6skHRFodkLC3vfm9x8EFgJfhsblLE,4477
+fmu/sumo/explorer/objects/_document.py,sha256=JMhlCr1XlXi1lE1-44WhISTNHiDw9gYGOTl0LUboQKo,1249
 fmu/sumo/explorer/objects/_metrics.py,sha256=q6CSeCjiN1SjNx4G32Lod7Slnflsu3aoJIpwm_VMIhQ,3954
-fmu/sumo/explorer/objects/_search_context.py,sha256=wfK27pobnZ_CUWq6jMMtwm3UETjmNVnOjcD7pqHJ734,49651
-fmu/sumo/explorer/objects/case.py,sha256=hA_9BqTG-ELqKrr1G2-kwx3nY0oVubcVMLaGBfAb3Qw,3545
+fmu/sumo/explorer/objects/_search_context.py,sha256=AvhrKZLbKnenFxQbFQcdRwPd8GhZxeK3tCWGC_8o4Bs,52740
+fmu/sumo/explorer/objects/case.py,sha256=D4MGn5lKNMdmaBvTJRYXu9xlGEOpuiMlZR_tsNs4AJU,3847
 fmu/sumo/explorer/objects/cases.py,sha256=L2LQieRTCJeNXRvXceHz9088nRO9gvKuRpsNpLI7Gnw,552
 fmu/sumo/explorer/objects/cpgrid.py,sha256=Va1M_rgHYdQfPFKFJvfDQhRcSZ_PnniCSI6uweaG3_s,2550
 fmu/sumo/explorer/objects/cpgrid_property.py,sha256=DxiFn6QrQCjXbDrxuxPi95b9pvkGI6nxxd0VoFn3e6k,2744
 fmu/sumo/explorer/objects/cube.py,sha256=UEFFx_qfS7o0cWNwVPxdO3Fee8Pst9J0GN1j6cXRd_o,3189
 fmu/sumo/explorer/objects/dictionary.py,sha256=56ol3ohxVwuesYsrULBE1a4pXXqcUnMWi41EX6_Zn-s,918
-fmu/sumo/explorer/objects/iteration.py,sha256=dvn1I3N_ww_Ls-pxVyMlRYbBb5EROn_zLGqc3y6OCcg,1003
+fmu/sumo/explorer/objects/iteration.py,sha256=iSQiQ2Epa98ZrySu47GMtJh2dsPnJVo9JqwSlEMRml4,1380
 fmu/sumo/explorer/objects/iterations.py,sha256=_d6fRmtVziy0qj-MucG_nPNTn6ffsTcIFGF0H2NqbTw,1606
 fmu/sumo/explorer/objects/polygons.py,sha256=z4maL5WI3cdFol3WlTYxhUJzMLkskfb_8Lz7QD4uqIY,1212
-fmu/sumo/explorer/objects/realization.py,sha256=CzRaJbGqrX1OANnkkSrdedEm6AP_bQWN5giM-FVE1m8,1090
+fmu/sumo/explorer/objects/realization.py,sha256=s5uSHCt9yoghhJByYIJp8KuWnoO6LPF2f0AkzRME8XI,1535
 fmu/sumo/explorer/objects/realizations.py,sha256=QnmrswpV34-AM05M6DP4BrD0vS3QKzPYaaCb18eeOEk,1616
 fmu/sumo/explorer/objects/surface.py,sha256=8SVYvCtpKISGd3gY_jIkTgTd_yTWIU8xiW9lcyTiMKU,1652
 fmu/sumo/explorer/objects/table.py,sha256=fRit1cWfCLqwZwLHK26D-qFT64uCYVjlVhDyXHWhO40,4925
 fmu/sumo/explorer/objects/table_aggregated.py,sha256=vq2EcR36JTcQsyCeyiMgigJMDFDQfVrlTZe2LdXrDFo,3794
-fmu_sumo-2.3.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fmu_sumo-2.3.4.dist-info/METADATA,sha256=W4kNoIvhVlhQNt_CT4xw_C34iHiAPf_vUcviaiTG2JM,14758
-fmu_sumo-2.3.4.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-fmu_sumo-2.3.4.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_sumo-2.3.4.dist-info/RECORD,,
+fmu_sumo-2.3.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fmu_sumo-2.3.6.dist-info/METADATA,sha256=uE43-k7ECxLJAKwVtVPfZNBzWI9rKoiONG7AJ3B46ZM,14758
+fmu_sumo-2.3.6.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+fmu_sumo-2.3.6.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_sumo-2.3.6.dist-info/RECORD,,