OTAnalytics 0.5.3__py3-none-any.whl

OTAnalytics/__main__.py

@@ -0,0 +1,13 @@
+import warnings
+
+from OTAnalytics.plugin_ui.main_application import ApplicationStarter
+
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+
+def main() -> None:
+    ApplicationStarter().start()
+
+
+if __name__ == "__main__":
+    main()

OTAnalytics/adapter_ui/abstract_button_quick_save_config.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractButtonQuickSaveConfig(ABC):
+
+    @abstractmethod
+    def set_state_changed_color(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_default_color(self) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_canvas.py

@@ -0,0 +1,25 @@
+from abc import abstractmethod
+
+from customtkinter import CTkCanvas
+
+from OTAnalytics.adapter_ui.helpers import WidgetPositionProvider
+
+# from OTAnalytics.plugin_ui.canvas_observer import EventHandler
+
+
+class AbstractCanvas(CTkCanvas, WidgetPositionProvider):
+    # TODO: Properly define abstract property here and in derived class(es)
+    # @property
+    # @abstractmethod
+    # def event_handler(self) -> EventHandler:
+    #     pass
+
+    # TODO: Define whole interface (all properties and methods) required by viewmodel
+
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def add_preview_image(self) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_frame.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractFrame(ABC):
+    @abstractmethod
+    def set_enabled_general_buttons(self, enabled: bool) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_enabled_add_buttons(self, enabled: bool) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_enabled_change_single_item_buttons(self, enabled: bool) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_enabled_change_multiple_items_buttons(self, enabled: bool) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_frame_canvas.py

@@ -0,0 +1,17 @@
+from abc import abstractmethod
+
+from OTAnalytics.domain.track import TrackImage
+
+
+class AbstractFrameCanvas:
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        pass
+
+    @abstractmethod
+    def update_background(self, image: TrackImage) -> None:
+        pass
+
+    @abstractmethod
+    def clear_image(self) -> None:
+        pass

OTAnalytics/adapter_ui/abstract_frame_filter.py

@@ -0,0 +1,50 @@
+from abc import ABC, abstractmethod
+
+from OTAnalytics.adapter_ui.dto import DateRangeDto
+
+
+class AbstractFrameFilter(ABC):
+    @abstractmethod
+    def _introduce_to_viewmodel(self) -> None:
+        pass
+
+    @abstractmethod
+    def set_active_color_on_filter_by_date_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def set_inactive_color_on_filter_by_date_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def set_active_color_on_filter_by_class_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def set_inactive_color_on_filter_by_class_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def enable_filter_by_date_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def disable_filter_by_date_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def enable_filter_by_class_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def disable_filter_by_class_button(self) -> None:
+        pass
+
+    @abstractmethod
+    def update_date_range(self, date_range: DateRangeDto) -> None:
+        pass
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Reset all filters."""
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_frame_project.py

@@ -0,0 +1,27 @@
+from abc import abstractmethod
+from datetime import datetime
+from typing import Optional
+
+
+class AbstractFrameProject:
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, name: str, start_date: Optional[datetime]) -> None:
+        pass
+
+    @abstractmethod
+    def set_enabled_general_buttons(self, enabled: bool) -> None:
+        raise NotImplementedError
+
+
+class AbstractFrameSvzMetadata:
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        pass
+
+    @abstractmethod
+    def update(self, metadata: dict) -> None:
+        pass

OTAnalytics/adapter_ui/abstract_frame_remark.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractFrameRemark(ABC):
+    @abstractmethod
+    def load_remark(self) -> None:
+        pass

OTAnalytics/adapter_ui/abstract_frame_track_plotting.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class AbstractFrameTrackPlotting(ABC):
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def reset_layers(self) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_frame_track_statistics.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+from OTAnalytics.application.use_cases.track_statistics import TrackStatistics
+
+
+class AbstractFrameTrackStatistics(ABC):
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_track_statistics(self, track_statistics: TrackStatistics) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_frame_tracks.py

@@ -0,0 +1,29 @@
+from abc import abstractmethod
+
+from OTAnalytics.plugin_ui.customtkinter_gui.abstract_ctk_frame import AbstractCTkFrame
+
+
+class AbstractFrameTracks(AbstractCTkFrame):
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_offset(self, new_offset_x: float, new_offset_y: float) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def configure_offset_button(self, color: str, enabled: bool) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def enable_update_offset_button(self, enabled: bool) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_offset_button_color(self, color: str) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_default_offset_button_color(self) -> str:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_main_window.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+from OTAnalytics.adapter_ui.helpers import WidgetPositionProvider
+
+
+class AbstractMainWindow(WidgetPositionProvider, ABC):
+    @abstractmethod
+    def introduce_to_viewmodel(self) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_progressbar_popup.py

@@ -0,0 +1,38 @@
+from abc import ABC, abstractmethod
+from tkinter import Widget
+from typing import Optional
+
+from OTAnalytics.domain.progress import Counter
+
+
+class AbstractPopupProgressbar(ABC):
+    def update_progress(self) -> None:
+        raise NotImplementedError
+
+
+class ProgressbarPopupBuilder(ABC):
+    def __init__(self) -> None:
+        self._master: Optional[Widget] = None
+        self._counter: Optional[Counter] = None
+        self._total: Optional[int] = None
+        self._description = ""
+        self._unit = ""
+
+    def add_widget(self, widget: Widget) -> None:
+        self._master = widget
+
+    def add_counter(self, counter: Counter) -> None:
+        self._counter = counter
+
+    def add_description(self, description: str) -> None:
+        self._description = description
+
+    def add_unit(self, unit: str) -> None:
+        self._unit = unit
+
+    def add_total(self, value: int) -> None:
+        self._total = value
+
+    @abstractmethod
+    def build(self) -> AbstractPopupProgressbar:
+        raise NotImplementedError

OTAnalytics/adapter_ui/abstract_treeview_interface.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+
+from OTAnalytics.adapter_ui.helpers import WidgetPositionProvider
+
+
+class AbstractTreeviewInterface(WidgetPositionProvider):
+    # TODO: add property viewmodel
+
+    @abstractmethod
+    def _introduce_to_viewmodel(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _notify_viewmodel_about_selected_item_ids(self, ids: list[str]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_items(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def update_selected_items(self, item_ids: list[str]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def enable(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def disable(self) -> None:
+        raise NotImplementedError

OTAnalytics/adapter_ui/default_values.py

@@ -0,0 +1,12 @@
+from OTAnalytics.domain.section import RelativeOffsetCoordinate
+
+RELATIVE_SECTION_OFFSET: RelativeOffsetCoordinate = RelativeOffsetCoordinate(0.5, 0.5)
+DATE_FORMAT: str = r"%Y-%m-%d"
+DATETIME_FORMAT: str = r"%Y-%m-%d %H:%M:%S"
+DATE_FORMAT_PLACEHOLDER = "yyyy-mm-dd"
+
+DATE_FORMAT_GERMAN: str = r"%d.%m.%Y"
+DATETIME_FORMAT_GERMAN: str = r"%d.%m.%Y %H:%M:%S"
+DATE_FORMAT_PLACEHOLDER_GERMAN = "dd.mm.yyyy"
+
+SUPPORTED_FORMATS: list[str] = [DATE_FORMAT, DATE_FORMAT_GERMAN]

OTAnalytics/adapter_ui/dto.py

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+
+class DateRangeDto(TypedDict):
+    start_date: str
+    end_date: str

OTAnalytics/adapter_ui/flow_adapter.py

@@ -0,0 +1,54 @@
+from abc import ABC, abstractmethod
+
+from OTAnalytics.domain.section import COORDINATES, Section
+
+
+class SectionRefPointCalculator(ABC):
+    def coordinates_from_section(self, section: Section) -> list[tuple[int, int]]:
+        coordinates_dicts = section.to_dict()[COORDINATES]
+        return [(d["x"], d["y"]) for d in coordinates_dicts]
+
+    @abstractmethod
+    def get_reference_point(self, section: Section) -> tuple[float, float]:
+        """
+        Calculates a reference point on a section.
+        Raises:
+            NotImplementedError: If derived classes have not implemented this method
+        Returns:
+            tuple[float, float]: Reference point
+        """
+        raise NotImplementedError
+
+
+class InnerSegmentsCenterCalculator(SectionRefPointCalculator):
+    def get_reference_point(self, section: Section) -> tuple[float, float]:
+        coordinates = self.coordinates_from_section(section)
+        num_coordinates = len(coordinates)
+        if num_coordinates == 0:
+            raise ValueError("LineSection has no coordinates")
+        if num_coordinates % 2 == 0:
+            # Calculate center between innermost two points
+            innermost_coordinates = coordinates[
+                num_coordinates // 2 - 1 : num_coordinates // 2 + 1
+            ]
+            center_x = (innermost_coordinates[0][0] + innermost_coordinates[1][0]) / 2
+            center_y = (innermost_coordinates[0][1] + innermost_coordinates[1][1]) / 2
+        else:
+            # Calculate innermost point
+            innermost_coordinate_index = len(coordinates) // 2
+            center_x, center_y = coordinates[innermost_coordinate_index]
+        return center_x, center_y
+
+
+class GeometricCenterCalculator(SectionRefPointCalculator):
+    def get_reference_point(self, section: Section) -> tuple[float, float]:
+        coordinates = self.coordinates_from_section(section)
+        total_x = 0
+        total_y = 0
+        num_points = len(coordinates)
+        for x, y in coordinates:
+            total_x += x
+            total_y += y
+        center_x = total_x / num_points
+        center_y = total_y / num_points
+        return center_x, center_y

OTAnalytics/adapter_ui/helpers.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+
+
+class WidgetPositionProvider(ABC):
+    @abstractmethod
+    def get_position(self, offset: tuple[float, float] = (0.5, 0.5)) -> tuple[int, int]:
+        raise NotImplementedError
+
+
+def remove_wildcard_from(file_extension: str) -> str:
+    return file_extension[1:] if file_extension.startswith("*") else file_extension
+
+
+def ensure_file_extension_is_present(
+    file: str, allowed_extensions: list[str], defaultextension: str
+) -> str:
+    """
+    Ensure that the file contains a file extension. If no extension is appended, the
+    defaultextension will be used.
+
+    Args:
+        file (str): file to ensure it has a file extension
+        allowed_extensions (list[str]): extensions that are allowed
+        defaultextension (str): default extension to be added if extension is missing
+
+    Returns:
+        Path: path object with file extension
+    """
+    if not file:
+        return ""
+    file_extension = remove_wildcard_from(defaultextension)
+    allowed_file_extensions = set(
+        [remove_wildcard_from(ext) for ext in allowed_extensions]
+    )
+    allowed_file_extensions.add(file_extension)
+    for allowed_extension in allowed_file_extensions:
+        if file.endswith(allowed_extension):
+            return file
+    if file_extension.startswith("."):
+        return file + file_extension
+    return f"{file}.{file_extension}"

OTAnalytics/adapter_ui/text_resources.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from typing import Iterator
+
+COLUMN_NAME = "column_name"
+
+
+@dataclass(frozen=True, order=True)
+class ColumnResource:
+    """
+    Represents a row in a treeview with an id and a dict of values to be shown.
+    The dicts keys represent the columns and the values represent the cell values.
+    """
+
+    id: str
+    values: dict[str, str]
+
+
+class ColumnResources:
+    def __init__(
+        self, resources: list[ColumnResource], lookup_column: str = COLUMN_NAME
+    ) -> None:
+        self._resources = resources
+        self._lookup_column = lookup_column
+        self._to_id = self._create_to_id(resources)
+        self._to_name = self._create_to_name(resources)
+
+    def _create_to_id(self, resources: list[ColumnResource]) -> dict[str, str]:
+        return {
+            resource.values[self._lookup_column]: resource.id for resource in resources
+        }
+
+    def _create_to_name(self, resources: list[ColumnResource]) -> dict[str, str]:
+        return {
+            resource.id: resource.values[self._lookup_column] for resource in resources
+        }
+
+    @property
+    def names(self) -> list[str]:
+        return [resource.values[self._lookup_column] for resource in self._resources]
+
+    def get_name_for(self, resource_id: str) -> str:
+        return self._to_name.get(resource_id, "")
+
+    def get_id_for(self, name: str) -> str:
+        return self._to_id.get(name, "")
+
+    def has(self, resource_id: str) -> bool:
+        return resource_id in [resource.id for resource in self._resources]
+
+    def __iter__(self) -> Iterator[ColumnResource]:
+        return self._resources.__iter__()

OTAnalytics/adapter_ui/ui_texts.py

@@ -0,0 +1,29 @@
+from OTAnalytics.application.project import (
+    CountingDayType,
+    DirectionOfStationing,
+    WeatherType,
+)
+
+DIRECTIONS_OF_STATIONING = {
+    DirectionOfStationing.IN_DIRECTION: "In Stationierungsrichtung",
+    DirectionOfStationing.OPPOSITE_DIRECTION: "Gegen Stationierungsrichtung",
+}
+
+COUNTING_DAY_TYPES = {
+    CountingDayType.NOW_1: "1. NoW",
+    CountingDayType.NOW_2: "2. NoW",
+    CountingDayType.FR_1: "1. Fr",
+    CountingDayType.FR_2: "2. Fr",
+    CountingDayType.SO_1: "1. So",
+    CountingDayType.SO_2: "2. So",
+    CountingDayType.FEW_1: "1. FeW",
+    CountingDayType.FEW_2: "2. FeW",
+}
+
+WEATHER_TYPES = {
+    WeatherType.SUN: "sonnig",
+    WeatherType.CLOUD: "bewölkt",
+    WeatherType.RAIN: "Regen",
+    WeatherType.SNOW: "Schnee",
+    WeatherType.FOG: "Nebel",
+}