fmu-settings 0.5.2__py3-none-any.whl → 0.14.1__py3-none-any.whl

fmu/settings/_resources/pydantic_resource_manager.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import copy
 import json
-from typing import TYPE_CHECKING, Any, Generic, Self, TypeVar
+from builtins import TypeError
+from typing import TYPE_CHECKING, Any, Final, Generic, Self, TypeVar
 
 from pydantic import BaseModel, ValidationError
 
+from fmu.settings.models.project_config import ProjectConfig
 from fmu.settings.types import ResettableBaseModel
 
 if TYPE_CHECKING:
@@ -22,6 +25,8 @@ MutablePydanticResource = TypeVar("MutablePydanticResource", bound=ResettableBas
 class PydanticResourceManager(Generic[PydanticResource]):
     """Base class for managing resources represented by Pydantic models."""
 
+    automatic_caching: bool = True
+
     def __init__(
         self: Self, fmu_dir: FMUDirectoryBase, model_class: type[PydanticResource]
     ) -> None:
@@ -53,6 +58,30 @@ class PydanticResourceManager(Generic[PydanticResource]):
         """Returns whether or not the resource exists."""
         return self.path.exists()
 
+    @staticmethod
+    def _get_dot_notation_key(
+        resource_dict: dict[str, Any], key: str, default: Any = None
+    ) -> Any:
+        """Get a value from the resource by a dot-notation key.
+
+        Args:
+            resource_dict: The resource dictionary to get the value from
+            key: The key to the value in the resource
+            default: Value to return if key is not found. Default None
+
+        Returns:
+            The value or default
+        """
+        parts = key.split(".")
+        value = resource_dict
+        for part in parts:
+            if isinstance(value, dict) and part in value:
+                value = value[part]
+            else:
+                return default
+
+        return value
+
     def load(
         self: Self, force: bool = False, store_cache: bool = True
     ) -> PydanticResource:
@@ -99,17 +128,103 @@ class PydanticResourceManager(Generic[PydanticResource]):
 
         return self._cache
 
-    def save(self: Self, model: PydanticResource) -> None:
+    def save(
+        self: Self,
+        model: PydanticResource,
+    ) -> None:
         """Save the Pydantic model to disk.
 
         Args:
-            model: Validated Pydantic model instance
+            model: Validated Pydantic model instance.
         """
         self.fmu_dir._lock.ensure_can_write()
+
         json_data = model.model_dump_json(by_alias=True, indent=2)
         self.fmu_dir.write_text_file(self.relative_path, json_data)
+
+        if self.automatic_caching and self.exists:
+            self.fmu_dir.cache.store_revision(self.relative_path, json_data)
+
         self._cache = model
 
+    @staticmethod
+    def get_model_diff(
+        current_model: BaseModel, incoming_model: BaseModel, prefix: str = ""
+    ) -> list[tuple[str, Any, Any]]:
+        """Recursively get differences between two Pydantic models.
+
+        Returns:
+            A list of differences between the models on field level.
+        """
+        if type(incoming_model) is not type(current_model):
+            raise ValueError(
+                "Models must be of the same type. Current model is of type "
+                f"'{current_model.__class__.__name__}', incoming model of type "
+                f"'{incoming_model.__class__.__name__}'."
+            )
+
+        IGNORED_FIELDS: Final[list[str]] = [
+            "created_at",
+            "created_by",
+            "last_modified_at",
+            "last_modified_by",
+        ]
+        changes: list[tuple[str, Any, Any]] = []
+
+        for field_name in type(current_model).model_fields:
+            if field_name in IGNORED_FIELDS:
+                continue
+
+            current_value = getattr(current_model, field_name)
+            incoming_value = getattr(incoming_model, field_name)
+
+            field_path = f"{prefix}.{field_name}" if prefix else field_name
+
+            if current_value is None and incoming_value is not None:
+                changes.append((field_path, None, incoming_value))
+            elif current_value is not None and incoming_value is None:
+                changes.append((field_path, current_value, None))
+            elif isinstance(current_value, BaseModel) and isinstance(
+                incoming_value, BaseModel
+            ):
+                changes.extend(
+                    PydanticResourceManager.get_model_diff(
+                        current_value, incoming_value, field_path
+                    )
+                )
+            elif isinstance(current_value, list) and isinstance(incoming_value, list):
+                if current_value != incoming_value:
+                    changes.append((field_path, current_value, incoming_value))
+            elif current_value != incoming_value:
+                changes.append((field_path, current_value, incoming_value))
+
+        return changes
+
+    def get_resource_diff(
+        self: Self, incoming_resource: PydanticResourceManager[PydanticResource]
+    ) -> list[tuple[str, Any, Any]]:
+        """Get differences between current and incoming Pydantic resource.
+
+        Returns:
+            A list of differences between the resources.
+        """
+        if self.exists and incoming_resource.exists:
+            current_model = self.load()
+            incoming_model = incoming_resource.load()
+            if type(current_model) is not type(incoming_model):
+                raise TypeError(
+                    f"Resources to diff must be of the same type. Current resource is "
+                    f"of type '{self.model_class.__name__}', incoming resource of type "
+                    f"'{incoming_model.__class__.__name__}'."
+                )
+            return self.get_model_diff(current_model, incoming_model)
+        raise FileNotFoundError(
+            "Resources to diff must exist in both directories: "
+            f"Current resource {str(self.relative_path)} exists: {self.exists}. "
+            f"Incoming resource {str(incoming_resource.relative_path)} exists: "
+            f"{incoming_resource.exists}."
+        )
+
 
 class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticResource]):
     """Manages the .fmu resource file."""
@@ -120,29 +235,6 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
         """Initializes the resource manager."""
         super().__init__(fmu_dir, resource)
 
-    def _get_dot_notation_key(
-        self: Self, resource_dict: dict[str, Any], key: str, default: Any = None
-    ) -> Any:
-        """Sets the value to a dot-notation key.
-
-        Args:
-            resource_dict: The resource dictionary we are modifying (by reference)
-            key: The key to set
-            default: Value to return if key is not found. Default None
-
-        Returns:
-            The value or default
-        """
-        parts = key.split(".")
-        value = resource_dict
-        for part in parts:
-            if isinstance(value, dict) and part in value:
-                value = value[part]
-            else:
-                return default
-
-        return value
-
     def get(self: Self, key: str, default: Any = None) -> Any:
         """Gets a resource value by key.
 
@@ -206,6 +298,7 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
         try:
             resource = self.load()
             resource_dict = resource.model_dump()
+            old_resource_dict = copy.deepcopy(resource_dict)
 
             if "." in key:
                 self._set_dot_notation_key(resource_dict, key, value)
@@ -214,6 +307,14 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
 
             updated_resource = resource.model_validate(resource_dict)
             self.save(updated_resource)
+
+            if self.model_class == ProjectConfig:
+                self.fmu_dir._changelog.log_update_to_changelog(
+                    updates={key: value},
+                    old_resource_dict=old_resource_dict,
+                    relative_path=self.relative_path,
+                )
+
         except ValidationError as e:
             raise ValueError(
                 f"Invalid value set for '{self.__class__.__name__}' with "
@@ -241,6 +342,7 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
         try:
             resource = self.load()
             resource_dict = resource.model_dump()
+            old_resource_dict = copy.deepcopy(resource_dict)
 
             flat_updates = {k: v for k, v in updates.items() if "." not in k}
             resource_dict.update(flat_updates)
@@ -251,6 +353,12 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
 
             updated_resource = resource.model_validate(resource_dict)
             self.save(updated_resource)
+
+            if self.model_class == ProjectConfig:
+                self.fmu_dir._changelog.log_update_to_changelog(
+                    updates, old_resource_dict, self.relative_path
+                )
+
         except ValidationError as e:
             raise ValueError(
                 f"Invalid value set for '{self.__class__.__name__}' with "
@@ -262,7 +370,7 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
                 f"at: '{self.path}' when setting updates {updates}"
             ) from e
 
-        return updated_resource
+        return self.load()
 
     def reset(self: Self) -> MutablePydanticResource:
         """Resets the resources to defaults.
@@ -273,3 +381,41 @@ class MutablePydanticResourceManager(PydanticResourceManager[MutablePydanticReso
         resource = self.model_class.reset()
         self.save(resource)
         return resource
+
+    def merge_resource(
+        self: Self,
+        incoming_resource: MutablePydanticResourceManager[MutablePydanticResource],
+    ) -> MutablePydanticResource:
+        """Merge an incoming Pydantic resource into the current resource model.
+
+        All changes in the incoming resource will be applied.
+
+        Returns:
+            The updated resource object
+        """
+        try:
+            changes: list[tuple[str, Any, Any]] = self.get_resource_diff(
+                incoming_resource
+            )
+            return self.merge_changes(changes)
+        except TypeError as e:
+            raise TypeError(
+                f"Merging pydantic resource failed. The incoming resource must be of "
+                f"type '{self.model_class.__name__}'. The provided model was of type "
+                f"'{incoming_resource.model_class.__name__}'."
+            ) from e
+
+    def merge_changes(
+        self: Self, changes: list[tuple[str, Any, Any]]
+    ) -> MutablePydanticResource:
+        """Merge a list of changes into the current resource model.
+
+        All changes will overwrite the current values.
+
+        Returns:
+            The updated resource object
+        """
+        updates: dict[str, Any] = {}
+        for change in changes:
+            updates[change[0]] = change[2]
+        return self.update(updates)

fmu/settings/_resources/user_session_log_manager.py

@@ -0,0 +1,47 @@
+"""Manages an .fmu user_session_log file."""
+
+from __future__ import annotations
+
+import contextlib
+from pathlib import Path
+from typing import TYPE_CHECKING, Self
+
+from fmu.settings._resources.log_manager import LogManager
+from fmu.settings.models.event_info import EventInfo
+from fmu.settings.models.log import Log, LogFileName
+
+if TYPE_CHECKING:
+    # Avoid circular dependency for type hint in __init__ only
+    from fmu.settings._fmu_dir import (
+        FMUDirectoryBase,
+    )
+
+
+class UserSessionLogManager(LogManager[EventInfo]):
+    """Manages the .fmu user session log file."""
+
+    def __init__(
+        self: Self, fmu_dir: FMUDirectoryBase, retention_days: int | None = None
+    ) -> None:
+        """Initializes the User session log resource manager."""
+        super().__init__(fmu_dir, Log[EventInfo])
+
+        # If user_session_log.json exists from previous session, cache it and delete
+        # We want a fresh log each time
+        if self.exists:
+            self.fmu_dir._lock.ensure_can_write()
+            content = self.fmu_dir.read_text_file(self.relative_path)
+            self.fmu_dir.cache.store_revision(
+                self.relative_path, content, skip_trim=True
+            )
+            with contextlib.suppress(FileNotFoundError):
+                self.path.unlink()
+
+        self.fmu_dir.cache.trim_by_age(
+            self.relative_path, retention_days or self.fmu_dir.cache.RETENTION_DAYS
+        )
+
+    @property
+    def relative_path(self: Self) -> Path:
+        """Returns the relative path to the log file."""
+        return Path("logs") / LogFileName.user_session_log

fmu/settings/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.5.2'
-__version_tuple__ = version_tuple = (0, 5, 2)
+__version__ = version = '0.14.1'
+__version_tuple__ = version_tuple = (0, 14, 1)
 
 __commit_id__ = commit_id = None

fmu/settings/models/_enums.py

@@ -32,3 +32,21 @@ class DataEntrySource(StrEnum):
 
 class TargetSystem(StrEnum):
     smda = "smda"
+
+
+class ChangeType(StrEnum):
+    """The types of change that can be made on a file."""
+
+    update = "update"
+    remove = "remove"
+    add = "add"
+    reset = "reset"
+    merge = "merge"
+
+
+class FilterType(StrEnum):
+    """The supported types to filter on."""
+
+    date = "date"
+    number = "number"
+    text = "text"

fmu/settings/models/change_info.py

@@ -0,0 +1,37 @@
+"""Model for the log entries in the the changelog file."""
+
+from datetime import UTC, datetime
+from pathlib import Path
+
+import pandas as pd
+from pydantic import AwareDatetime, BaseModel, Field, field_validator
+
+from fmu.settings.models._enums import ChangeType
+
+
+class ChangeInfo(BaseModel):
+    """Represents a change in the changelog file."""
+
+    timestamp: AwareDatetime = Field(
+        default_factory=lambda: datetime.now(UTC), strict=True
+    )
+    change_type: ChangeType
+    user: str
+    path: Path
+    change: str
+    hostname: str
+    file: str
+    key: str
+
+    @field_validator("timestamp", mode="before")
+    @classmethod
+    def convert_timestamp(cls, value: str) -> AwareDatetime:
+        """Convert timestamp values given as a 'str' or Pandas 'Timestamp'.
+
+        Values of other types will be handled by Pydantic.
+        """
+        if isinstance(value, str):
+            return datetime.fromisoformat(value)
+        if isinstance(value, pd.Timestamp):
+            return value.to_pydatetime()
+        return value

fmu/settings/models/event_info.py

@@ -0,0 +1,15 @@
+"""Model for the log entries in the the userlog file."""
+
+from datetime import UTC, datetime
+
+from pydantic import AwareDatetime, BaseModel, ConfigDict, Field
+
+
+class EventInfo(BaseModel):
+    """Represents information about user session activity."""
+
+    model_config = ConfigDict(extra="allow")
+
+    level: str = "INFO"
+    event: str = "unknown"
+    timestamp: AwareDatetime = Field(default_factory=lambda: datetime.now(UTC))

fmu/settings/models/log.py

@@ -0,0 +1,63 @@
+"""Module for the log file and related models."""
+
+from datetime import datetime
+from enum import StrEnum
+from typing import Any, Literal, Self, TypeVar
+
+from pydantic import BaseModel, Field, RootModel
+
+from fmu.settings.models._enums import FilterType
+
+LogEntryType = TypeVar("LogEntryType", bound=BaseModel)
+
+
+class Log(RootModel[list[LogEntryType]]):
+    """Represents a log file in a .fmu directory."""
+
+    root: list[LogEntryType] = Field(default_factory=list)
+
+    def add_entry(self: Self, entry: LogEntryType) -> None:
+        """Adds a log entry to the log."""
+        self.root.append(entry)
+
+    def __getitem__(self: Self, index: int) -> LogEntryType:
+        """Retrieves a log entry from the log using the specified index."""
+        return self.root[index]
+
+    def __iter__(self: Self) -> Any:
+        """Returns an iterator for the log."""
+        return iter(self.root)
+
+    def __len__(self: Self) -> int:
+        """Returns the number of log entries in the log."""
+        return len(self.root)
+
+
+class Filter(BaseModel):
+    """Represents a filter that can be applied on a log file."""
+
+    field_name: str
+    filter_value: str
+    filter_type: FilterType
+    operator: Literal[">", ">=", "<", "<=", "==", "!="]
+
+    def parse_filter_value(self: Self) -> str | datetime | int:
+        """Parse filter value to its type."""
+        match self.filter_type:
+            case FilterType.date:
+                return datetime.fromisoformat(self.filter_value)
+            case FilterType.number:
+                return int(self.filter_value)
+            case FilterType.text:
+                return self.filter_value
+            case _:
+                raise ValueError(
+                    "Invalid filter type supplied when parsing filter value."
+                )
+
+
+class LogFileName(StrEnum):
+    """The log files in the .fmu directory."""
+
+    changelog = "changelog.json"
+    user_session_log = "user_session_log.json"

fmu/settings/models/project_config.py

@@ -2,15 +2,61 @@
 
 import getpass
 from datetime import UTC, datetime
+from pathlib import Path
 from typing import Self
 
-from pydantic import AwareDatetime, Field
+from pydantic import AwareDatetime, BaseModel, Field
 
 from fmu.datamodels.fmu_results.fields import Access, Masterdata, Model
 from fmu.settings import __version__
 from fmu.settings.types import ResettableBaseModel, VersionStr  # noqa: TC001
 
 
+class RmsCoordinateSystem(BaseModel):
+    """The project coordinate system of an RMS project."""
+
+    name: str
+    """Name of the coordinate system."""
+
+
+class RmsStratigraphicZone(BaseModel):
+    """A stratigraphic zone from an RMS project."""
+
+    name: str
+    """Name of the zone."""
+
+    top_horizon_name: str
+    """Name of the horizon at the top of the zone."""
+
+    base_horizon_name: str
+    """Name of the horizon at the base of the zone."""
+
+
+class RmsHorizon(BaseModel):
+    """A horizon from an RMS project."""
+
+    name: str
+    """Name of the horizon."""
+
+
+class RmsWell(BaseModel):
+    """A well from an RMS project."""
+
+    name: str
+    """Name of the well."""
+
+
+class RmsProject(BaseModel):
+    """RMS project configuration."""
+
+    path: Path
+    version: str
+    coordinate_system: RmsCoordinateSystem | None = None
+    zones: list[RmsStratigraphicZone] | None = None
+    horizons: list[RmsHorizon] | None = None
+    wells: list[RmsWell] | None = None
+
+
 class ProjectConfig(ResettableBaseModel):
     """The configuration file in a .fmu directory.
 
@@ -20,9 +66,13 @@ class ProjectConfig(ResettableBaseModel):
     version: VersionStr
     created_at: AwareDatetime
     created_by: str
-    masterdata: Masterdata | None = Field(default=None)
-    model: Model | None = Field(default=None)
-    access: Access | None = Field(default=None)
+    last_modified_at: AwareDatetime | None = None
+    last_modified_by: str | None = None
+    masterdata: Masterdata | None = None
+    model: Model | None = None
+    access: Access | None = None
+    cache_max_revisions: int = Field(default=5, ge=5)
+    rms: RmsProject | None = None
 
     @classmethod
     def reset(cls: type[Self]) -> Self:
@@ -35,7 +85,11 @@ class ProjectConfig(ResettableBaseModel):
             version=__version__,
             created_at=datetime.now(UTC),
             created_by=getpass.getuser(),
+            last_modified_at=None,
+            last_modified_by=None,
             masterdata=None,
             model=None,
             access=None,
+            cache_max_revisions=5,
+            rms=None,
         )

fmu/settings/models/user_config.py

@@ -10,6 +10,7 @@ import annotated_types
 from pydantic import (
     AwareDatetime,
     BaseModel,
+    Field,
     SecretStr,
     field_serializer,
     field_validator,
@@ -42,6 +43,8 @@ class UserConfig(ResettableBaseModel):
 
     version: VersionStr
     created_at: AwareDatetime
+    last_modified_at: AwareDatetime | None = None
+    cache_max_revisions: int = Field(default=5, ge=5)
     user_api_keys: UserAPIKeys
     recent_project_directories: RecentProjectDirectories
 
@@ -51,6 +54,8 @@ class UserConfig(ResettableBaseModel):
         return cls(
             version=__version__,
             created_at=datetime.now(UTC),
+            last_modified_at=None,
+            cache_max_revisions=5,
             user_api_keys=UserAPIKeys(),
             recent_project_directories=[],
         )

{fmu_settings-0.5.2.dist-info → fmu_settings-0.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu-settings
-Version: 0.5.2
+Version: 0.14.1
 Summary: A library for managing FMU settings
 Author-email: Equinor <fg-fmu_atlas@equinor.com>
 License: GPL-3.0
@@ -21,9 +21,11 @@ Requires-Dist: PyYAML
 Requires-Dist: annotated_types
 Requires-Dist: fmu-config
 Requires-Dist: fmu-datamodels
+Requires-Dist: pandas
 Requires-Dist: pydantic
 Provides-Extra: dev
 Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pandas-stubs; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: pytest-mock; extra == "dev"

fmu_settings-0.14.1.dist-info/RECORD

@@ -0,0 +1,32 @@
+fmu/__init__.py,sha256=htx6HlMme77I6pZ8U256-2B2cMJuELsu3JN3YM2Efh4,144
+fmu/settings/__init__.py,sha256=CkEE7al_uBCQO1lxBKN5LzyCwzzH5Aq6kkEIR7f-zTw,336
+fmu/settings/_fmu_dir.py,sha256=lmGliopDfB2QiWWAowzuaTGcN_nCYzb58-4woBAi-2g,19769
+fmu/settings/_global_config.py,sha256=C0_o99OhOc49ynz4h6ygbbHHH8OOI5lcVFr-9FCwD0c,9331
+fmu/settings/_init.py,sha256=rgt5aZou54RiVAOegC4kzoigJcZefPY4Kv6ke7OAIxI,4014
+fmu/settings/_logging.py,sha256=nEdmZlNCBsB1GfDmFMKCjZmeuRp3CRlbz1EYUemc95Y,1104
+fmu/settings/_readme_texts.py,sha256=0N3Tn3sUKc3PdTiaWzfe7fu7aAphdwMvlG_4ag3h3UE,1067
+fmu/settings/_version.py,sha256=a3VJZDtDsD7dO22j4y92zbdkUlJwzXf_QabiVquJm1Y,706
+fmu/settings/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu/settings/types.py,sha256=aeXEsznBTT1YRRY_LSRqK1j2gmMmyLYYTGYl3a9fweU,513
+fmu/settings/_resources/__init__.py,sha256=LHYR_F7lNGdv8N6R3cEwds5CJQpkOthXFqsEs24vgF8,118
+fmu/settings/_resources/cache_manager.py,sha256=QxmIM0jJRgJsmD_69juPRnUmGrRJ6ZbFp6wc-KW7baA,7192
+fmu/settings/_resources/changelog_manager.py,sha256=ubb7gqWKlAzuh3WyWSRXFFjl8Kso4amTKJPLNf4t6Mw,5857
+fmu/settings/_resources/config_managers.py,sha256=HULkmmxKHN0_aDkPd3DrLaWv2X-njBBCQwXU-H55jdw,2334
+fmu/settings/_resources/lock_manager.py,sha256=tqDqMhovED52a8vEcoJCbfJqgKAk2lsp5eUOtZteU00,10512
+fmu/settings/_resources/log_manager.py,sha256=Ru7dLE6Ugnz0NYORf29kZdkrg3scV7v7z8xDiKP7wEI,3736
+fmu/settings/_resources/pydantic_resource_manager.py,sha256=F2XDWx4RQktJSKC247J2EtJvsmT_DzZGJ9oE2Tt63Zs,14927
+fmu/settings/_resources/user_session_log_manager.py,sha256=aGbOkjyvqKPTdKyhtNUmuWIWyRqsXIcVrNTgmq8e2yc,1610
+fmu/settings/models/__init__.py,sha256=lRlXgl55ba2upmDzdvzx8N30JMq2Osnm8aa_xxTZn8A,112
+fmu/settings/models/_enums.py,sha256=sBvn-2sYVToK7WBMR6PGHtdkh1MwDB0d1_6oWJMIvII,1054
+fmu/settings/models/_mappings.py,sha256=Z4Ex7MtmajBr6FjaNzmwDRwtJlaZZ8YKh9NDmZHRKPI,2832
+fmu/settings/models/change_info.py,sha256=5X8wIItSt_xQ3AQF8EB5moxgIDC_ZyO6Hqkxhdj9l5c,1038
+fmu/settings/models/event_info.py,sha256=7AVDT7QEBHgKTUOHw4ofltQAY9yiYD6aYY8ilO55_9Q,429
+fmu/settings/models/lock_info.py,sha256=-oHDF9v9bDLCoFvEg4S6XXYLeo19zRAZ8HynCv75VWg,711
+fmu/settings/models/log.py,sha256=aP5lQTnKBIiyiTmiMXig0TEpA2yhKz6VOsymaP6EOYk,1943
+fmu/settings/models/project_config.py,sha256=68aEugx7uwkDvVT2vAoS7F6ez8R91cvU0ULf3hwS-rE,2371
+fmu/settings/models/user_config.py,sha256=XYxGhvdIPkQeMWBOwZKekvC-2ldwT1OhrGh9piBxVgk,2851
+fmu_settings-0.14.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+fmu_settings-0.14.1.dist-info/METADATA,sha256=Zbdj0rdx5SNw1qGME_Gkdvk_wMvFUJFUyoWgHFhbRgw,2183
+fmu_settings-0.14.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_settings-0.14.1.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
+fmu_settings-0.14.1.dist-info/RECORD,,

fmu_settings-0.5.2.dist-info/RECORD

@@ -1,24 +0,0 @@
-fmu/__init__.py,sha256=htx6HlMme77I6pZ8U256-2B2cMJuELsu3JN3YM2Efh4,144
-fmu/settings/__init__.py,sha256=CkEE7al_uBCQO1lxBKN5LzyCwzzH5Aq6kkEIR7f-zTw,336
-fmu/settings/_fmu_dir.py,sha256=XeZjec78q0IUOpBq-VMkKoWtzXwBeQi2qWRIh_SIFwU,10859
-fmu/settings/_global_config.py,sha256=C0_o99OhOc49ynz4h6ygbbHHH8OOI5lcVFr-9FCwD0c,9331
-fmu/settings/_init.py,sha256=ucueS0BlEsM3MkX7IaRISloH4vF7-_ZKSphrORbHgJ4,4381
-fmu/settings/_logging.py,sha256=nEdmZlNCBsB1GfDmFMKCjZmeuRp3CRlbz1EYUemc95Y,1104
-fmu/settings/_version.py,sha256=LGYtjQ6cyPZC_N0AovMIeSYYDK21050nm3HYgDanQBM,704
-fmu/settings/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fmu/settings/types.py,sha256=aeXEsznBTT1YRRY_LSRqK1j2gmMmyLYYTGYl3a9fweU,513
-fmu/settings/_resources/__init__.py,sha256=LHYR_F7lNGdv8N6R3cEwds5CJQpkOthXFqsEs24vgF8,118
-fmu/settings/_resources/config_managers.py,sha256=QcCLlSw8KdJKrkhGax5teFJzjgQG3ym7Ljs1DykjFbc,1570
-fmu/settings/_resources/lock_manager.py,sha256=ekGE5mTcjEWRyoBSIeqaX1r53-WStpYeJYepkOPYi3Q,10061
-fmu/settings/_resources/pydantic_resource_manager.py,sha256=BUWO6IHSoT0Ma6QgseweEf7uiGeMwHBEoCyGYPYYFdA,9290
-fmu/settings/models/__init__.py,sha256=lRlXgl55ba2upmDzdvzx8N30JMq2Osnm8aa_xxTZn8A,112
-fmu/settings/models/_enums.py,sha256=SQUZ-2mQcTx4F0oefPFfuQzMKsKTSFSB-wq_CH7TBRE,734
-fmu/settings/models/_mappings.py,sha256=Z4Ex7MtmajBr6FjaNzmwDRwtJlaZZ8YKh9NDmZHRKPI,2832
-fmu/settings/models/lock_info.py,sha256=-oHDF9v9bDLCoFvEg4S6XXYLeo19zRAZ8HynCv75VWg,711
-fmu/settings/models/project_config.py,sha256=pxb54JmpXNMVAFUu_yJ89dNrYEk6hrPuFfFUpf84Jh0,1099
-fmu/settings/models/user_config.py,sha256=dWFTcZY6UnEgNTuGqB-izraJ657PecsW0e0Nt9GBDhI,2666
-fmu_settings-0.5.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-fmu_settings-0.5.2.dist-info/METADATA,sha256=dxi2pe4SgYJwTY6beiEPoLx7lEqjzZWq9UcpX3gir_s,2116
-fmu_settings-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_settings-0.5.2.dist-info/top_level.txt,sha256=Z-FIY3pxn0UK2Wxi9IJ7fKoLSraaxuNGi1eokiE0ShM,4
-fmu_settings-0.5.2.dist-info/RECORD,,