flood-adapt 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

flood_adapt/objects/events/event_factory.py

@@ -1,135 +1,135 @@
-from pathlib import Path
-from typing import Any, List
-
-import tomli
-
-from flood_adapt.objects.events.event_set import EventSet
-from flood_adapt.objects.events.events import (
-    Event,
-    Mode,
-    Template,
-)
-from flood_adapt.objects.events.historical import HistoricalEvent
-from flood_adapt.objects.events.hurricane import (
-    HurricaneEvent,
-    TranslationModel,
-)
-from flood_adapt.objects.events.synthetic import SyntheticEvent
-
-__all__ = ["TranslationModel", "EventSet"]
-
-
-class EventFactory:
-    """Factory class for creating events.
-
-    This class is used to create events based on a template.
-
-    Attributes
-    ----------
-    _EVENT_TEMPLATES : dict[str, (Event, Event)]
-        Dictionary mapping event templates to event classes and models
-    """
-
-    _EVENT_TEMPLATES = {
-        Template.Hurricane: HurricaneEvent,
-        Template.Historical: HistoricalEvent,
-        Template.Synthetic: SyntheticEvent,
-    }
-
-    @staticmethod
-    def get_event_from_template(template: Template) -> type[Event]:
-        """Get the event class corresponding to the template.
-
-        Parameters
-        ----------
-        template : str
-            Name of the event template
-
-        Returns
-        -------
-        Type[Event]
-            Event template
-        """
-        if template not in EventFactory._EVENT_TEMPLATES:
-            raise ValueError(f"Invalid event template: {template}")
-        return EventFactory._EVENT_TEMPLATES[template]
-
-    @staticmethod
-    def read_template(filepath: Path) -> Template:
-        """Get event template from toml file."""
-        if not filepath.exists():
-            raise FileNotFoundError(f"File not found: {filepath}")
-        with open(filepath, mode="rb") as fp:
-            toml = tomli.load(fp)
-        if (template := toml.get("template")) is None:
-            raise ValueError(f"Event template not found in {filepath}")
-
-        return Template(template)
-
-    @staticmethod
-    def read_mode(filepath: Path) -> Mode:
-        """Get event mode from toml file."""
-        if not filepath.exists():
-            raise FileNotFoundError(f"File not found: {filepath}")
-        with open(filepath, mode="rb") as fp:
-            toml = tomli.load(fp)
-        if toml.get("mode") is None:
-            raise ValueError(f"Event mode not found in {filepath}")
-        return Mode(toml.get("mode"))
-
-    @staticmethod
-    def load_file(toml_file: Path) -> Event:
-        """Return event object based on toml file.
-
-        Parameters
-        ----------
-        toml_file : str
-            Template name
-
-        Returns
-        -------
-        Event
-            Event object
-        """
-        mode = EventFactory.read_mode(toml_file)
-        if mode == Mode.risk:
-            event_type = EventSet
-        elif mode == Mode.single_event:
-            template = Template(EventFactory.read_template(toml_file))
-            event_type = EventFactory.get_event_from_template(template)
-        else:
-            raise ValueError(f"Invalid event mode: {mode}")
-        return event_type.load_file(toml_file)
-
-    @staticmethod
-    def load_dict(attrs: dict[str, Any] | Event) -> Event | EventSet:
-        """Return event object based on attrs dict.
-
-        Parameters
-        ----------
-        attrs : dict[str, Any]
-            Event attributes
-
-        Returns
-        -------
-        Event
-            Event object based on template
-        """
-        if isinstance(attrs, Event):
-            mode = attrs.mode
-            template = attrs.template
-        else:
-            mode = Mode(attrs.get("mode"))
-            template = Template(attrs.get("template"))
-
-        if mode == Mode.risk:
-            # TODO Load events
-            return EventSet(**attrs)
-        elif mode == Mode.single_event:
-            return EventFactory.get_event_from_template(template)(**attrs)
-        else:
-            raise ValueError(f"Invalid event mode: {mode}")
-
-    @staticmethod
-    def get_allowed_forcings(template) -> dict[str, List[str]]:
-        return EventFactory.get_event_from_template(template).get_allowed_forcings()
+from pathlib import Path
+from typing import Any, List
+
+import tomli
+
+from flood_adapt.objects.events.event_set import EventSet
+from flood_adapt.objects.events.events import (
+    Event,
+    Mode,
+    Template,
+)
+from flood_adapt.objects.events.historical import HistoricalEvent
+from flood_adapt.objects.events.hurricane import (
+    HurricaneEvent,
+    TranslationModel,
+)
+from flood_adapt.objects.events.synthetic import SyntheticEvent
+
+__all__ = ["TranslationModel", "EventSet"]
+
+
+class EventFactory:
+    """Factory class for creating events.
+
+    This class is used to create events based on a template.
+
+    Attributes
+    ----------
+    _EVENT_TEMPLATES : dict[str, (Event, Event)]
+        Dictionary mapping event templates to event classes and models
+    """
+
+    _EVENT_TEMPLATES = {
+        Template.Hurricane: HurricaneEvent,
+        Template.Historical: HistoricalEvent,
+        Template.Synthetic: SyntheticEvent,
+    }
+
+    @staticmethod
+    def get_event_from_template(template: Template) -> type[Event]:
+        """Get the event class corresponding to the template.
+
+        Parameters
+        ----------
+        template : str
+            Name of the event template
+
+        Returns
+        -------
+        Type[Event]
+            Event template
+        """
+        if template not in EventFactory._EVENT_TEMPLATES:
+            raise ValueError(f"Invalid event template: {template}")
+        return EventFactory._EVENT_TEMPLATES[template]
+
+    @staticmethod
+    def read_template(filepath: Path) -> Template:
+        """Get event template from toml file."""
+        if not filepath.exists():
+            raise FileNotFoundError(f"File not found: {filepath}")
+        with open(filepath, mode="rb") as fp:
+            toml = tomli.load(fp)
+        if (template := toml.get("template")) is None:
+            raise ValueError(f"Event template not found in {filepath}")
+
+        return Template(template)
+
+    @staticmethod
+    def read_mode(filepath: Path) -> Mode:
+        """Get event mode from toml file."""
+        if not filepath.exists():
+            raise FileNotFoundError(f"File not found: {filepath}")
+        with open(filepath, mode="rb") as fp:
+            toml = tomli.load(fp)
+        if toml.get("mode") is None:
+            raise ValueError(f"Event mode not found in {filepath}")
+        return Mode(toml.get("mode"))
+
+    @staticmethod
+    def load_file(toml_file: Path, load_all: bool = False) -> Event | EventSet:
+        """Return event object based on toml file.
+
+        Parameters
+        ----------
+        toml_file : str
+            Template name
+
+        Returns
+        -------
+        Event
+            Event object
+        """
+        mode = EventFactory.read_mode(toml_file)
+        if mode == Mode.risk:
+            return EventSet.load_file(toml_file, load_all=load_all)
+        elif mode == Mode.single_event:
+            template = Template(EventFactory.read_template(toml_file))
+            event_type = EventFactory.get_event_from_template(template)
+            return event_type.load_file(toml_file)
+        else:
+            raise ValueError(f"Invalid event mode: {mode}")
+
+    @staticmethod
+    def load_dict(attrs: dict[str, Any] | Event) -> Event | EventSet:
+        """Return event object based on attrs dict.
+
+        Parameters
+        ----------
+        attrs : dict[str, Any]
+            Event attributes
+
+        Returns
+        -------
+        Event
+            Event object based on template
+        """
+        if isinstance(attrs, Event):
+            mode = attrs.mode
+            template = attrs.template
+        else:
+            mode = Mode(attrs.get("mode"))
+            template = Template(attrs.get("template"))
+
+        if mode == Mode.risk:
+            # TODO Load events
+            return EventSet(**attrs)
+        elif mode == Mode.single_event:
+            return EventFactory.get_event_from_template(template)(**attrs)
+        else:
+            raise ValueError(f"Invalid event mode: {mode}")
+
+    @staticmethod
+    def get_allowed_forcings(template) -> dict[str, List[str]]:
+        return EventFactory.get_event_from_template(template).get_allowed_forcings()

flood_adapt/objects/events/event_set.py

@@ -1,84 +1,88 @@
-import os
-from pathlib import Path
-from typing import List, Optional
-
-import tomli
-from pydantic import BaseModel
-
-from flood_adapt.objects.events.events import Event, Mode
-from flood_adapt.objects.object_model import Object
-
-
-class SubEventModel(BaseModel):
-    """The accepted input for a sub event in FloodAdapt.
-
-    Attributes
-    ----------
-    name : str
-        The name of the sub event.
-    frequency : float
-        The frequency of the sub event.
-    """
-
-    name: str
-    frequency: float
-
-
-class EventSet(Object):
-    """BaseModel describing the expected variables and data types for parameters of EventSet.
-
-    An EventSet is a collection of events that can be used to create a scenario and perform a probabilistoc risk assessment.
-
-    Attributes
-    ----------
-    name : str
-        The name of the event.
-    description : str
-        The description of the event. Defaults to "".
-    mode : Mode
-        The mode of the event. Defaults to Mode.risk.
-    sub_events : List[SubEventModel]
-        The sub events of the event set.
-    """
-
-    _events: Optional[List[Event]] = None
-
-    mode: Mode = Mode.risk
-    sub_events: List[SubEventModel]
-
-    def load_sub_events(
-        self,
-        sub_events: Optional[List[Event]] = None,
-        file_path: Optional[Path] = None,
-    ) -> None:
-        """Load sub events from a list or from a file path."""
-        if sub_events is not None:
-            self._events = sub_events
-        elif file_path is not None:
-            from flood_adapt.objects.events.event_factory import EventFactory
-
-            sub_events = []
-            for sub_event in self.sub_events:
-                sub_toml = (
-                    Path(file_path).parent / sub_event.name / f"{sub_event.name}.toml"
-                )
-                sub_events.append(EventFactory.load_file(sub_toml))
-
-            self._events = sub_events
-        else:
-            raise ValueError("Either `sub_events` or `file_path` must be provided.")
-
-    @classmethod
-    def load_file(cls, file_path: Path | str | os.PathLike):
-        """Load object from file."""
-        with open(file_path, mode="rb") as fp:
-            event_set = tomli.load(fp)
-        event_set = EventSet(**event_set)
-        event_set.load_sub_events(file_path=file_path)
-        return event_set
-
-    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
-        for sub_event in self._events:
-            sub_dir = Path(output_dir) / sub_event.name
-            sub_dir.mkdir(parents=True, exist_ok=True)
-            sub_event.save(sub_dir / f"{sub_event.name}.toml")
+import os
+from pathlib import Path
+from typing import List, Optional
+
+import tomli
+from pydantic import BaseModel
+
+from flood_adapt.objects.events.events import Event, Mode
+from flood_adapt.objects.object_model import Object
+
+
+class SubEventModel(BaseModel):
+    """The accepted input for a sub event in FloodAdapt.
+
+    Attributes
+    ----------
+    name : str
+        The name of the sub event.
+    frequency : float
+        The frequency of the sub event.
+    """
+
+    name: str
+    frequency: float
+
+
+class EventSet(Object):
+    """BaseModel describing the expected variables and data types for parameters of EventSet.
+
+    An EventSet is a collection of events that can be used to create a scenario and perform a probabilistic risk assessment.
+
+    Attributes
+    ----------
+    name : str
+        The name of the event.
+    description : str
+        The description of the event. Defaults to "".
+    mode : Mode
+        The mode of the event. Defaults to Mode.risk.
+    sub_events : List[SubEventModel]
+        The sub events of the event set.
+    """
+
+    _events: Optional[List[Event]] = None
+
+    mode: Mode = Mode.risk
+    sub_events: List[SubEventModel]
+
+    def load_sub_events(
+        self,
+        sub_events: Optional[List[Event]] = None,
+        file_path: Optional[Path] = None,
+    ) -> None:
+        """Load sub events from a list or from a file path."""
+        if sub_events is not None:
+            self._events = sub_events
+        elif file_path is not None:
+            from flood_adapt.objects.events.event_factory import EventFactory
+
+            sub_events = []
+            for sub_event in self.sub_events:
+                sub_toml = (
+                    Path(file_path).parent / sub_event.name / f"{sub_event.name}.toml"
+                )
+                sub_events.append(EventFactory.load_file(sub_toml))
+
+            self._events = sub_events
+        else:
+            raise ValueError("Either `sub_events` or `file_path` must be provided.")
+
+    @classmethod
+    def load_file(
+        cls, file_path: Path | str | os.PathLike, load_all: bool = False
+    ) -> "EventSet":
+        """Load object from file."""
+        with open(file_path, mode="rb") as fp:
+            event_set = tomli.load(fp)
+        event_set = EventSet(**event_set)
+        if load_all:
+            # Load all sub events from the file path
+            event_set.load_sub_events(file_path=file_path)
+        return event_set
+
+    def save_additional(self, output_dir: Path | str | os.PathLike) -> None:
+        for sub_event in self._events:
+            sub_dir = Path(output_dir) / sub_event.name
+            sub_dir.mkdir(parents=True, exist_ok=True)
+            sub_event.save(sub_dir / f"{sub_event.name}.toml")