Added missing analysis config state for full otconfig re-deserialization

Author: schubsen

OTAnalytics/application/application.py

@@ -9,10 +9,12 @@
 )
 from OTAnalytics.application.datastore import Datastore
 from OTAnalytics.application.key_prefix import S3KeyPrefix
+from OTAnalytics.application.parser.config_parser import StaticAnalysisConfig
 from OTAnalytics.application.project import SvzMetadata
 from OTAnalytics.application.state import (
     ActionState,
     CurrentKeyPrefix,
+    CurrentStaticAnalysisConfigState,
     FileState,
     FlowState,
     SectionState,
@@ -160,6 +162,7 @@ def __init__(
         get_current_remark: GetCurrentRemark,
         update_count_plots: CountPlotsUpdater,
         current_key_prefix: CurrentKeyPrefix,
+        current_static_analysis_config_state: CurrentStaticAnalysisConfigState,
     ) -> None:
         self._datastore: Datastore = datastore
         self.track_state: TrackState = track_state
@@ -208,6 +211,9 @@ def __init__(
         self._get_current_remark = get_current_remark
         self._update_count_plots = update_count_plots
         self._current_key_prefix = current_key_prefix
+        self._current_static_analysis_config_state = (
+            current_static_analysis_config_state
+        )
 
     def connect_observers(self) -> None:
         """
@@ -317,6 +323,14 @@ def get_current_key_prefix(self) -> S3KeyPrefix | None:
         """
         return self._current_key_prefix.get()
 
+    def get_current_static_analysis_config(self) -> StaticAnalysisConfig:
+        """Get the current static analysis configuration.
+
+        Returns:
+            StaticAnalysisConfig: the current static analysis configuration.
+        """
+        return self._current_static_analysis_config_state.get()
+
     def load_otconfig(self, file: Path) -> None:
         """Load an otconfig, blocking. Outside an event loop only."""
         self._load_otconfig.load(file)

OTAnalytics/application/config.py

@@ -49,6 +49,7 @@
 DEFAULT_SAVE_SUFFIX = ""
 DEFAULT_EVENT_FORMATS = {"csv"}
 DEFAULT_LOG_FILE = Path("logs")
+DEFAULT_NUM_PROCESSES = 1
 
 
 OS: str = platform.system()

OTAnalytics/application/parser/config_parser.py

@@ -32,6 +32,18 @@ class AnalysisConfig:
     logfile: Path
 
 
+@dataclass(frozen=True)
+class StaticAnalysisConfig:
+    """The subset of the AnalysisConfig that stays fixed while the
+    application runs."""
+
+    do_events: bool
+    do_counting: bool
+    export_config: ExportConfig
+    num_processes: int
+    logfile: Path
+
+
 @dataclass(frozen=True)
 class SubstitutedFile:
     """A reference an otconfig named, and the file loaded in its place.
@@ -97,8 +109,8 @@ def parse_from_dict(self, data: dict, base_folder: Path) -> OtConfig:
     def serialize(
         self,
         project: Project,
+        analysis_config: AnalysisConfig,
         video_files: Iterable[Video],
-        track_files: Iterable[Path],
         sections: Iterable[Section],
         flows: Iterable[Flow],
         file: Path,
@@ -110,8 +122,9 @@ def serialize(
 
         Args:
             project (Project): description of the project
+            analysis_config (AnalysisConfig): analysis settings to store,
+                including the track files to reference
             video_files (Iterable[Video]): video files to reference
-            track_files (Iterable[Path]): track files to reference
             sections (Iterable[Section]): sections to store
             flows (Iterable[Flow]): flows to store
             file (Path): output file
@@ -139,8 +152,8 @@ def serialize_from_config(self, config: OtConfig, file: Path) -> None:
     def convert(
         self,
         project: Project,
+        analysis_config: AnalysisConfig,
         video_files: Iterable[Video],
-        track_files: Iterable[Path],
         sections: Iterable[Section],
         flows: Iterable[Flow],
         file: Path,

OTAnalytics/application/state.py

@@ -6,9 +6,28 @@
 from typing import Callable, Generic, Optional
 
 from OTAnalytics.application.analysis.traffic_counting import CountImage
-from OTAnalytics.application.config import DEFAULT_TRACK_OFFSET
+from OTAnalytics.application.analysis.traffic_counting_specification import (
+    CountingEvent,
+)
+from OTAnalytics.application.config import (
+    DEFAULT_COUNTING_EVENT,
+    DEFAULT_COUNTING_INTERVAL_IN_MINUTES,
+    DEFAULT_DO_COUNTING,
+    DEFAULT_DO_EVENTS,
+    DEFAULT_EVENT_FORMATS,
+    DEFAULT_LOG_FILE,
+    DEFAULT_NUM_PROCESSES,
+    DEFAULT_SAVE_NAME,
+    DEFAULT_SAVE_SUFFIX,
+    DEFAULT_TRACK_OFFSET,
+)
 from OTAnalytics.application.datastore import Datastore
 from OTAnalytics.application.key_prefix import S3KeyPrefix
+from OTAnalytics.application.parser.config_parser import (
+    AnalysisConfig,
+    ExportConfig,
+    StaticAnalysisConfig,
+)
 from OTAnalytics.application.playback import SkipTime
 from OTAnalytics.application.use_cases.section_repository import GetSectionsById
 from OTAnalytics.domain.date import DateRange
@@ -810,3 +829,69 @@ def __init__(self) -> None:
 
     def reset(self) -> None:
         self.last_saved_config.set(None)
+
+
+class CurrentExportConfigState:
+    def __init__(self) -> None:
+        self.save_name: str
+        self.save_suffix: str
+        self.event_formats: set[str]
+        self.count_intervals: set[int]
+        self.counting_event: CountingEvent
+        self.reset()
+
+    def get(self) -> ExportConfig:
+        return ExportConfig(
+            save_name=self.save_name,
+            save_suffix=self.save_suffix,
+            event_formats=self.event_formats,
+            count_intervals=self.count_intervals,
+            counting_event=self.counting_event,
+        )
+
+    def set(self, export_config: ExportConfig) -> None:
+        self.save_name = export_config.save_name
+        self.save_suffix = export_config.save_suffix
+        self.event_formats = export_config.event_formats
+        self.count_intervals = export_config.count_intervals
+        self.counting_event = export_config.counting_event
+
+    def reset(self) -> None:
+        self.save_name = DEFAULT_SAVE_NAME
+        self.save_suffix = DEFAULT_SAVE_SUFFIX
+        self.event_formats = DEFAULT_EVENT_FORMATS
+        self.count_intervals = {DEFAULT_COUNTING_INTERVAL_IN_MINUTES}
+        self.counting_event = CountingEvent.parse(DEFAULT_COUNTING_EVENT)
+
+
+class CurrentStaticAnalysisConfigState:
+    def __init__(self) -> None:
+        self.do_events: bool
+        self.do_counting: bool
+        self.export_config: CurrentExportConfigState = CurrentExportConfigState()
+        self.num_processes: int
+        self.logfile: Path
+        self.reset()
+
+    def get(self) -> StaticAnalysisConfig:
+        return StaticAnalysisConfig(
+            do_events=self.do_events,
+            do_counting=self.do_counting,
+            export_config=self.export_config.get(),
+            num_processes=self.num_processes,
+            logfile=self.logfile,
+        )
+
+    def set_from_analysis_config(self, analysis_config: AnalysisConfig) -> None:
+        self.do_events = analysis_config.do_events
+        self.do_counting = analysis_config.do_counting
+        self.export_config.set(analysis_config.export_config)
+        self.num_processes = analysis_config.num_processes
+        self.logfile = analysis_config.logfile
+
+    def reset(self) -> None:
+        self.do_events = DEFAULT_DO_EVENTS
+        self.do_counting = DEFAULT_DO_COUNTING
+        self.export_config.reset()
+        self.num_processes = DEFAULT_NUM_PROCESSES
+        self.logfile = DEFAULT_LOG_FILE

OTAnalytics/application/use_cases/config.py

@@ -5,6 +5,9 @@
 from OTAnalytics.application.parser.config_parser import ConfigParser
 from OTAnalytics.application.state import ConfigurationFile, CurrentKeyPrefix, FileState
 from OTAnalytics.application.upload_otconfig import UploadOtconfig
+from OTAnalytics.application.use_cases.get_current_analysis_config import (
+    GetCurrentAnalysisConfig,
+)
 from OTAnalytics.application.use_cases.get_current_remark import GetCurrentRemark
 
 
@@ -24,13 +27,15 @@ def __init__(
         state: FileState,
         get_current_remark: GetCurrentRemark,
         current_key_prefix: CurrentKeyPrefix,
+        get_current_analysis_config: GetCurrentAnalysisConfig,
         otconfig_upload: UploadOtconfig,
     ) -> None:
         self._datastore = datastore
         self._config_parser = config_parser
         self._state = state
         self._get_current_remark = get_current_remark
         self._current_key_prefix = current_key_prefix
+        self._get_current_analysis_config = get_current_analysis_config
         self._otconfig_upload = otconfig_upload
 
     async def __call__(self, file: Path) -> None:
@@ -47,18 +52,18 @@ async def __call__(self, file: Path) -> None:
             raise ConfigValidationError(errors)
 
         video_files = self._datastore.get_all_videos()
-        track_files = self._datastore._track_file_repository.get_all()
         sections = self._datastore.get_all_sections()
         flows = self._datastore.get_all_flows()
         remark = self._get_current_remark.get()
         # The same value reaches `convert` below. Passing it to only one of the
         # two would make every project report itself as permanently unsaved.
         s3_key_prefix = self._current_key_prefix.get()
+        analysis_config = self._get_current_analysis_config.get()
         logger().info(f"Saving otconfig to '{file}'")
         self._config_parser.serialize(
             project=project,
+            analysis_config=analysis_config,
             video_files=video_files,
-            track_files=track_files,
             sections=sections,
             flows=flows,
             file=file,
@@ -69,14 +74,14 @@ async def __call__(self, file: Path) -> None:
             ConfigurationFile(
                 file,
                 self._config_parser.convert(
-                    project,
-                    video_files,
-                    track_files,
-                    sections,
-                    flows,
-                    file,
-                    remark,
-                    s3_key_prefix,
+                    project=project,
+                    analysis_config=analysis_config,
+                    video_files=video_files,
+                    sections=sections,
+                    flows=flows,
+                    file=file,
+                    remark=remark,
+                    s3_key_prefix=s3_key_prefix,
                 ),
             )
         )

OTAnalytics/application/use_cases/config_has_changed.py

@@ -2,10 +2,12 @@
 from OTAnalytics.application.parser.flow_parser import FlowParser
 from OTAnalytics.application.state import ConfigurationFile, CurrentKeyPrefix, FileState
 from OTAnalytics.application.use_cases.flow_repository import GetAllFlows
+from OTAnalytics.application.use_cases.get_current_analysis_config import (
+    GetCurrentAnalysisConfig,
+)
 from OTAnalytics.application.use_cases.get_current_project import GetCurrentProject
 from OTAnalytics.application.use_cases.get_current_remark import GetCurrentRemark
 from OTAnalytics.application.use_cases.section_repository import GetAllSections
-from OTAnalytics.application.use_cases.track_repository import GetAllTrackFiles
 from OTAnalytics.application.use_cases.video_repository import GetAllVideos
 
 
@@ -17,18 +19,18 @@ def __init__(
         get_flows: GetAllFlows,
         get_current_project: GetCurrentProject,
         get_videos: GetAllVideos,
-        get_track_files: GetAllTrackFiles,
         get_remark: GetCurrentRemark,
         current_key_prefix: CurrentKeyPrefix,
+        get_current_analysis_config: GetCurrentAnalysisConfig,
     ):
         self._config_parser = config_parser
         self._get_sections = get_sections
         self._get_flows = get_flows
         self._get_current_project = get_current_project
         self._get_videos = get_videos
-        self._get_track_files = get_track_files
         self._get_remark = get_remark
         self._current_key_prefix = current_key_prefix
+        self._get_current_analysis_config = get_current_analysis_config
 
     def has_changed(self, prev_config: ConfigurationFile) -> bool:
         """
@@ -41,14 +43,14 @@ def has_changed(self, prev_config: ConfigurationFile) -> bool:
             bool: True if the OTConfig file has changed, False otherwise.
         """
         current_content = self._config_parser.convert(
-            self._get_current_project.get(),
-            self._get_videos.get(),
-            self._get_track_files(),
-            self._get_sections(),
-            self._get_flows.get(),
-            prev_config.file,
-            self._get_remark.get(),
-            self._current_key_prefix.get(),
+            project=self._get_current_project.get(),
+            analysis_config=self._get_current_analysis_config.get(),
+            video_files=self._get_videos.get(),
+            sections=self._get_sections(),
+            flows=self._get_flows.get(),
+            file=prev_config.file,
+            remark=self._get_remark.get(),
+            s3_key_prefix=self._current_key_prefix.get(),
         )
         return prev_config.content != current_content
 

OTAnalytics/application/use_cases/get_current_analysis_config.py

@@ -0,0 +1,36 @@
+from OTAnalytics.application.parser.config_parser import AnalysisConfig
+from OTAnalytics.application.state import CurrentStaticAnalysisConfigState
+from OTAnalytics.application.use_cases.track_repository import GetAllTrackFiles
+
+
+class GetCurrentAnalysisConfig:
+    """Provide the analysis configuration currently held by the application.
+
+    Args:
+        static_analysis_config_state (CurrentStaticAnalysisConfigState): the state
+            holding the analysis settings that are not derived from repositories.
+        get_all_track_files (GetAllTrackFiles): use case to retrieve all track files.
+    """
+
+    def __init__(
+        self,
+        static_analysis_config_state: CurrentStaticAnalysisConfigState,
+        get_all_track_files: GetAllTrackFiles,
+    ) -> None:
+        self._static_analysis_config_state = static_analysis_config_state
+        self._get_all_track_files = get_all_track_files
+
+    def get(self) -> AnalysisConfig:
+        """Get the current analysis configuration.
+
+        Returns:
+            AnalysisConfig: The current analysis configuration.
+        """
+        return AnalysisConfig(
+            do_events=self._static_analysis_config_state.do_events,
+            do_counting=self._static_analysis_config_state.do_counting,
+            track_files=self._get_all_track_files(),
+            export_config=self._static_analysis_config_state.export_config.get(),
+            num_processes=self._static_analysis_config_state.num_processes,
+            logfile=self._static_analysis_config_state.logfile,
+        )