work-tracker 0.1.0__py3-none-any.whl

work_tracker/__init__.py

@@ -0,0 +1,8 @@
+from .version import VERSION, __version__
+from ._work_tracker import WorkTracker
+
+__all__ = (
+    "__version__",
+    "VERSION",
+    "WorkTracker",
+)

work_tracker/_work_tracker.py

@@ -0,0 +1,236 @@
+import calendar
+import datetime
+import shutil
+import signal
+import subprocess
+import sys
+import traceback
+from pathlib import Path
+
+from workalendar.registry import registry
+
+from work_tracker import __version__
+from work_tracker.checkpoint_manager import CheckpointManager
+from work_tracker.command.command_parser import CommandParser
+from work_tracker.command.command_query_handler import CommandQueryHandler
+from work_tracker.command.common import ParseResult
+from work_tracker.common import AppData, Date, Mode, AppState, get_data_path
+from work_tracker.text.common import Color
+from work_tracker.text.input_output_handler import InputOutputHandler
+from .config import Config
+from .error import VersionCheckError
+
+
+class WorkTracker:
+    def __init__(self):
+        self.state: AppState = AppState()
+        self.data: AppData
+        self.io: InputOutputHandler
+        self.command_handler: CommandQueryHandler
+        self._initialized: bool = False
+
+    def initialize(self, check_is_new_version_available: bool = True):
+        self._initialized = True
+
+        if is_first_time_launch := self._is_first_time_launch():
+            self._create_basic_files()
+        if was_version_file_missing := self._is_version_file_missing():
+            self._update_version_file()
+        if was_config_file_missing := self._is_config_file_missing():
+            self._create_default_config_file()
+        if was_macros_file_missing := self._is_macros_file_missing():
+            self._create_default_macros_file()
+        if was_updated_since_last_launch := self._was_updated_since_last_launch():
+            self._update_version_file()
+
+        # config access check must be before io, because io uses config values
+        if not Config.ready():
+            raise RuntimeError("Something went wrong trying to access config.")
+
+        self._initialize_io()
+        if is_first_time_launch:
+            self._first_time_prompt()
+        else:
+            if was_version_file_missing:
+                self.io.output("WARNING: version file could not be found. This may lead to unpredicted behavior.", color=Color.Yellow)
+            if was_config_file_missing:
+                self.io.output("WARNING: config file could not be found. Default config will be used instead.", color=Color.Yellow)
+            if was_macros_file_missing:
+                self.io.output("WARNING: macros file could not be found. Default macros will be used instead.", color=Color.Yellow)
+
+        if not is_first_time_launch:
+            self._load_data()
+            if self.data is None:
+                self.io.output("WARNING: it appears that no saved data file was found to load from. As a result, the app will default to the first-time launch screen.", color=Color.Yellow)
+                self._first_time_prompt()
+            elif not self.data.is_latest_data_version():
+                self.data.update_data_to_latest_version()
+
+        self._initialize_command_handler()
+        self._clear_old_cache()
+
+        if not was_updated_since_last_launch and check_is_new_version_available and (latest_version := self._is_new_version_available()) is not None:
+            self._display_new_version_available_message(latest_version)
+        self.io.output(f"Using {Color.Brightblue.value}WorkTracker{Color.Clear.value} version {Color.Brightblue.value}{__version__}{Color.Clear.value}.")
+
+    def _is_first_time_launch(self) -> bool:
+        expected_files: list[Path] = [get_data_path().joinpath("version"), get_data_path().joinpath("config.yaml"), get_data_path().joinpath("macros.txt")]
+        return all(not path.exists() for path in expected_files)
+
+    def _create_basic_files(self):
+        self._create_default_config_file()
+        self._create_default_macros_file()
+
+    def _create_default_config_file(self):
+        shutil.copy(Path(__file__).parent.joinpath("data/default.config.yaml"), get_data_path().joinpath("config.yaml"))
+
+    def _create_default_macros_file(self):
+        shutil.copy(Path(__file__).parent.joinpath("data/default.macros.txt"), get_data_path().joinpath("macros.txt"))
+
+    def _initialize_io(self):
+        self.io = InputOutputHandler()
+
+    def _load_data(self):
+        self.data = CheckpointManager.load_latest()
+
+    def _first_time_prompt(self):
+        self.io.write("Welcome to WorkTracker!", color=Color.Brightblue)
+        self.io.write("WorkTracker helps you track your work hours efficiently and manage your schedule with ease.", color=Color.Cyan)
+        self.io.output(f"Before you start using it, please provide your country code. This will allow {Color.Brightblue.value}WorkTracker{Color.Reset.value} to automatically import all relevant holidays and mark your non-working days accordingly.")
+
+        country_code: str
+        valid_codes: list[str] = sorted(list(registry.get_calendars().keys()))
+        while True:
+            country_code = self.io.input(f"{Config.data.input.prefix} ", custom_autocomplete=valid_codes).upper()
+            if country_code in valid_codes: # TODO use of private method
+                break
+            else:
+                self.io.output("Invalid country code. Please input valid contry code.", color=Color.Brightred)
+
+        self.io.output("Would you like to run the initial setup? This process can take some time but is recommended, as it enables the app to automatically fill your calendar with the suggested work schedule.")
+        user_input: str = self.io.input(f"{Config.data.input.prefix} ", custom_autocomplete=["yes", "no"])
+        if "yes".startswith(user_input):
+            self.io.output("Setup command is not yet implemented. Skipping setup phase...", color=Color.Brightred)
+        else:
+            self.io.output(f"Initial setup skipped. You can always run setup later by using {Color.Brightblue.value}setup{Color.Reset.value} command.")
+
+        self.data = AppData(country_code=country_code)
+        CheckpointManager.save("initial", self.data)
+
+        self.io.write(f"Everything is set up and ready.", color=Color.Cyan, end=" ")
+        self.io.write(f"To view a list of available commands type {Color.Brightblue.value}help{Color.Reset.value}.", end=" ")
+        self.io.write(f"For detailed information about a specific command use {Color.Brightblue.value}help <command_name>{Color.Reset.value}.", end=" ")
+        self.io.write(f"It is recommended that you use {Color.Brightblue.value}tutorial{Color.Reset.value} command to quickly get familiar with the available features.", end=" ")
+        self.io.output(f"Remember to leave {Color.Brightblue.value}WorkTracker{Color.Reset.value} by using {Color.Brightblue.value}exit{Color.Reset.value} command to avoid {Color.Underline.value}{Color.Brightred.value}loss of data{Color.Reset.value}!")
+
+    def _is_version_file_missing(self) -> bool:
+        return not get_data_path().joinpath("version").exists() # TODO make file name a constant
+
+    def _is_config_file_missing(self) -> bool:
+        return not get_data_path().joinpath("config.yaml").exists() # TODO make file name a constant
+
+    def _is_macros_file_missing(self) -> bool:
+        return not get_data_path().joinpath("macros.txt").exists() # TODO make file name a constant
+
+    def _was_updated_since_last_launch(self) -> bool:
+        path: Path = get_data_path().joinpath("version")
+        if not path.exists():
+            raise RuntimeError("Something went wrong when trying to access version file.")
+
+        with open(path, "r") as file:
+            version: str = file.read()
+
+        return version < __version__
+
+    def _update_version_file(self):
+        with open(get_data_path().joinpath("version"), "w") as file:
+            file.write(__version__)
+
+    def _initialize_command_handler(self):
+        self.command_handler = CommandQueryHandler(self.data, self.io, self.state)
+
+    def _is_new_version_available(self) -> str | None:
+        try:
+            installed_version: str = __version__
+            result = subprocess.run(
+                ["pip", "index", "versions", "work-tracker"],
+                capture_output=True, text=True
+            )
+            if result.returncode != 0:
+                self.io.output("WARNING: unable to retrieve data from pip while checking for available updates.", color=Color.Yellow)
+                return None
+
+            latest_version: str = result.stdout.strip().split("\n")[-1].split()[-1]
+            return latest_version if installed_version != latest_version else None
+        except subprocess.SubprocessError as e:
+            raise VersionCheckError("Subprocess error during version check.")
+        except Exception as e:
+            raise VersionCheckError(f"Unexpected error: {e}")
+
+    def _display_new_version_available_message(self, version: str):
+        self.io.write(f"New version {Color.Brightcyan.value}{version}{Color.Reset.value} is available!", end=" ")
+        self.io.output(f"Update with {Color.Brightblue.value}pip install --upgrade work-tracker{Color.Reset.value}.")
+
+    def _clear_old_cache(self):
+        CheckpointManager.clear_cache()
+
+    def _at_crash_exit(self, crash_message: str | None = None, exception: Exception | None = None):
+        CheckpointManager.save(f"crash-{datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}", self.data)
+        with open(get_data_path().joinpath(f"crash-log-{datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.txt"), "w") as file:
+            if crash_message is not None:
+                file.write(crash_message)
+            if exception is not None:
+                traceback.print_exc(file=file)
+        sys.exit()
+
+    def _at_exit(self):
+        CheckpointManager.save(f"{datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}", self.data)
+        sys.exit()
+
+    def handle_exit_signal(self): # TODO check if this works | no it doesnt :(
+        self._at_crash_exit(crash_message=f"received exit signal")
+
+    def _run(self):
+        error_log_last_processed_input: str = "None"
+        try:
+            while True:
+                today: Date = Date.today()
+                mode: Mode = self.state.mode
+                date: Date = self.state.active_date
+                prefix: str = (
+                    f"{Config.data.input.prefix} "                                            if mode == Mode.Today else
+                    f"[{date.day:02}.{date.month:02}.{date.year}]{Config.data.input.prefix} " if mode == Mode.Day and today.year != date.year else
+                    f"[{date.day:02}.{date.month:02}]{Config.data.input.prefix} "             if mode == Mode.Day and today.year == date.year else
+                    f"[{calendar.month_abbr[date.month].lower()}]{Config.data.input.prefix} " if mode == Mode.Month else
+                    "?> "
+                )
+
+                user_input: str = self.get_user_input(prefix)
+                error_log_last_processed_input = user_input
+
+                result: ParseResult = CommandParser.parse(user_input)
+                if result.error:
+                    self.io.output(f"ERROR: {result.error.message or 'missing error description'}", color=Color.Brightred)
+                    continue
+
+                for query in result.queries:
+                    self.command_handler.run(query)
+        except KeyboardInterrupt:
+            self.io.output("UNSAFE EXIT: saving data...", color=Color.Brightred, end="")
+            self._at_exit()
+        except Exception as exception:
+            self.io.output("FATAL ERROR: saving data and creating error log...", color=Color.Brightred, end="")
+            self._at_crash_exit(crash_message=f"{error_log_last_processed_input}\n\n", exception=exception)
+
+    def start(self):
+        if not self._initialized:
+            self.initialize()
+
+        # TODO add atexit.register() to automatically save data somewhere here ?
+        signal.signal(signal.SIGINT, self.handle_exit_signal)
+        signal.signal(signal.SIGTERM, self.handle_exit_signal)
+
+        self._run()
+
+    def get_user_input(self, prefix: str) -> str:
+        return self.io.input(prefix)

work_tracker/checkpoint_manager.py

@@ -0,0 +1,56 @@
+import datetime
+import lzma
+import os
+import pickle
+
+from path import Path
+
+from .common import AppData, get_data_path, get_cache_path
+
+
+class CheckpointManager:
+    @classmethod
+    def load(cls, identifier: str, manual_checkpoint: bool = False) -> AppData | None: # TODO os exceptions
+        if manual_checkpoint:
+            for checkpoint_path in cls.all_manual_checkpoints():
+                name, date = checkpoint_path.name.removesuffix('.save.checkpoint').split("__") # TODO hardcoded '.save.checkpoint'
+                if name == identifier:
+                    identifier = f"{name}__{date}"
+
+        path: Path = (get_data_path() if not manual_checkpoint else get_cache_path()).joinpath(f"{identifier}.save.checkpoint")
+        if not path.exists():
+            return None
+        with lzma.open(path, "rb") as file:
+            data: AppData = pickle.load(file)
+        return data
+
+    @staticmethod
+    def save(identifier: str, data: AppData, manual_checkpoint: bool = False): # TODO os exceptions
+        full_identifier: str = identifier if not manual_checkpoint else f"{identifier}__{datetime.datetime.now().strftime('%H-%M-%S')}"
+        path: Path = (get_data_path() if not manual_checkpoint else get_cache_path()).joinpath(f"{full_identifier}.save.checkpoint")
+        with lzma.open(path, "wb") as file:
+            pickle.dump(data, file)
+
+    @classmethod
+    def load_latest(cls) -> AppData | None: # TODO os exceptions
+        files: list[Path] = cls.all_automatic_checkpoints()
+        if not files:
+            return None
+
+        newest_file: str = max(files, key=os.path.getctime) # TODO this sorting might be unclear for user
+        return cls.load(os.path.basename(newest_file.rstrip(".save.checkpoint")))
+
+    @staticmethod
+    def all_automatic_checkpoints() -> list[Path]: # TODO os exceptions
+        return [get_data_path().joinpath(file) for file in os.listdir(get_data_path()) if file.endswith(".save.checkpoint") and os.path.isfile(get_data_path().joinpath(file))]
+
+    @staticmethod
+    def all_manual_checkpoints() -> list[Path]: # TODO os exceptions
+        return [get_cache_path().joinpath(file) for file in os.listdir(get_cache_path()) if file.endswith(".save.checkpoint") and os.path.isfile(get_cache_path().joinpath(file))]
+
+    @staticmethod
+    def clear_cache():
+        for name in os.listdir(get_cache_path()):
+            if not os.path.isfile(get_cache_path().joinpath(name)):
+                continue
+            os.remove(get_cache_path().joinpath(name))

work_tracker/command/__init__.py

@@ -0,0 +1 @@
+

work_tracker/command/command_handler.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from work_tracker.command.command_parser import CommandParser
+from work_tracker.command.common import CommandArgument, AdditionalInputArgument, CommandQuery
+from work_tracker.error import CommandError
+from work_tracker.common import AppData, Date, ReadonlyAppState
+from work_tracker.config import Config
+from work_tracker.text.input_output_handler import InputOutputHandler
+
+
+@dataclass(frozen=True)
+class CommandHandlerResult:
+    undoable: bool
+    error: CommandError | None = None
+    change_active_date: Date | None = None
+    change_state_by: int | None = None
+    execute_after: list[CommandQuery] | None = None
+
+
+class CommandHandler(ABC):
+    def __init__(self, work_data: AppData, io: InputOutputHandler):
+        self.data: AppData = work_data
+        self.io: InputOutputHandler = io
+
+    @property
+    def command_name(self) -> str:
+        return self.__class__.__name__.split("Handler")[0].lower()
+
+    @abstractmethod
+    def handle(self, dates: list[Date], date_count: int, arguments: list[CommandArgument], argument_count: int, state: ReadonlyAppState) -> CommandHandlerResult:
+        raise NotImplementedError()
+
+    def get_additional_input(self, custom_autocomplete: list[str] = None) -> list[AdditionalInputArgument]:
+        text: str = self.io.input(f"{Config.data.input.sub_prefix} ", show_autocomplete=custom_autocomplete is not None, custom_autocomplete=custom_autocomplete)
+        return CommandParser.parse_arguments(text)

work_tracker/command/command_history.py

@@ -0,0 +1,48 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CommandHistoryEntry:
+    state_key: str
+    command: str
+
+
+class CommandHistory:
+    def __init__(self, max_size: int):
+        self._max_size: int = max_size
+        self._current_state_index: int = -1
+        self._states: list[CommandHistoryEntry] = []
+
+    def add(self, state_key: str, command_used: str):
+        if self._current_state_index < self._max_size:
+            self._states = self._states[:self._current_state_index + 1]
+
+        if self._current_state_index == self._max_size:
+            self._states.pop(0)
+        else:
+            self._current_state_index += 1
+
+        self._states.append(CommandHistoryEntry(
+            state_key=state_key,
+            command=command_used
+        ))
+
+    def undo(self) -> str | None:
+        if self._current_state_index > 0:
+            self._current_state_index -= 1
+            return self._states[self._current_state_index].state_key
+        return None
+
+    def redo(self) -> str | None:
+        if self._current_state_index < len(self._states) - 1:
+            self._current_state_index += 1
+            return self._states[self._current_state_index].state_key
+        return None
+
+    @property
+    def states(self) -> tuple[CommandHistoryEntry]:
+        return tuple(self._states)
+
+    @property
+    def current_state_index(self) -> int:
+        return self._current_state_index

work_tracker/command/command_initializer.py

@@ -0,0 +1,88 @@
+import re
+
+from work_tracker.command.common import Command, CommandTemplate
+
+
+class CommandInitializer:
+    _shortest_command_string: dict[str, str] = {} # key: value -> shortest_command_string: command_name
+
+    @classmethod
+    def reset(cls):
+        cls._shortest_command_string.clear()
+
+    @classmethod
+    def initialize_commands(cls, commands: list[CommandTemplate]) -> list[Command]:
+        cls.reset()
+
+        commands_dict: dict[str, CommandTemplate] = {command.name: command for command in commands}
+        if len(commands_dict.keys()) != len(commands):
+            raise RuntimeError(f"Could not initialize commands, there are duplicated command names.")
+
+        cls._find_not_conflicting_shortest_command_string_for(commands)
+
+        return [
+            Command(
+                name=command_name,
+                help=commands_dict[command_name].help,
+                abbreviations=commands_dict[command_name].abbreviations,
+                shortest_valid_string=shortest_string,
+                snake_case_name=re.sub(r'[-. ]', '_', command_name),
+                camel_case_name="".join(word.capitalize() for word in re.sub(r'[-. ]', '_', command_name).split('_')),
+                valid_argument_types=sorted(commands_dict[command_name].valid_argument_types, key=len),
+                supported_modes=commands_dict[command_name].supported_modes,
+            ) for shortest_string, command_name in sorted(cls._shortest_command_string.items())
+        ]
+
+    @classmethod
+    def _find_not_conflicting_shortest_command_string_for(cls, commands: list[CommandTemplate]):
+        target_string_length: int = 1
+        abbreviations: set[str] = cls._get_abbreviations(commands)
+
+        commands_left: list[str] = [command.name for command in commands]
+        while len(commands_left) != 0:
+            commands_left = cls._find_not_conflicting_command_string_of_length_for(commands_left, abbreviations, target_string_length)
+            target_string_length += 1
+
+    @classmethod
+    def _get_abbreviations(cls, commands: list[CommandTemplate]) -> set[str]:
+        abbreviations: set[str] = set()
+        for command in commands:
+            for abbreviation in command.abbreviations:
+                if abbreviation in abbreviations:
+                    raise RuntimeError(f"Could not initialize commands, found duplicated command abbreviation: '{abbreviation}'.")
+                abbreviations.add(abbreviation)
+        return abbreviations
+
+    @classmethod
+    def _find_not_conflicting_command_string_of_length_for(cls, commands: list[str], abbreviations: set[str], target_string_length: int) -> list[str]: # TODO check if this can be simplified
+        remaining_commands: set[str] = set()
+        substrings_to_pop: set[str] = set()
+
+        for command in commands:
+            command_substring: str = command[:target_string_length]
+            substring_is_full_command_name: bool = len(command_substring) == len(command)
+            substring_is_an_abbreviation: bool = command_substring in abbreviations
+            substring_already_exists: bool = command_substring in cls._shortest_command_string.keys()
+            found_substring_is_full_command_name: bool = command_substring == cls._shortest_command_string.get(command_substring)
+
+            if substring_is_an_abbreviation and substring_is_full_command_name:
+                raise RuntimeError(f"Command '{command}' could not be shorten and is equal to one of the special abbreviations of another command.")
+            elif substring_is_an_abbreviation:
+                remaining_commands.add(command)
+            elif substring_already_exists and substring_is_full_command_name:
+                remaining_commands.add(cls._shortest_command_string[command_substring])
+                substrings_to_pop.add(command_substring)
+                cls._shortest_command_string[command_substring] = command
+            elif substring_already_exists and not found_substring_is_full_command_name:
+                remaining_commands.add(cls._shortest_command_string[command_substring])
+                remaining_commands.add(command)
+                substrings_to_pop.add(command_substring)
+            elif not substring_already_exists or substring_is_full_command_name:
+                cls._shortest_command_string[command_substring] = command
+            else:
+                remaining_commands.add(command)
+
+        for substring in substrings_to_pop:
+            cls._shortest_command_string.pop(substring)
+
+        return list(remaining_commands)

work_tracker/command/command_manager.py

@@ -0,0 +1,85 @@
+from work_tracker.command.command_initializer import CommandInitializer
+from work_tracker.command.common import Command, TimeArgument, CommandHelp, _global_command_templates
+from work_tracker.common import Mode
+
+
+class CommandManager:
+    _commands: list[Command] = []
+
+    # special commands
+    _time_command: Command = Command(
+        help=CommandHelp(
+            full_use_case_template="",
+            short_help_description="",
+            full_help_description="",
+            use_case_description=[],
+        ),
+        supported_modes=set(Mode),
+        abbreviations=[],
+        name="__time",
+        shortest_valid_string="",
+        snake_case_name="__time",
+        camel_case_name="__Time",
+        valid_argument_types=[[TimeArgument]]
+    )
+    _date_command: Command = Command(
+        help=CommandHelp(
+            full_use_case_template="",
+            short_help_description="",
+            full_help_description="",
+            use_case_description=[],
+        ),
+        supported_modes=set(Mode),
+        abbreviations=[],
+        name="__date",
+        shortest_valid_string="",
+        snake_case_name="__date",
+        camel_case_name="__Date",
+        valid_argument_types=[[]]
+    )
+    _macro_execute_command: Command = Command(
+        help=CommandHelp(
+            full_use_case_template="",
+            short_help_description="",
+            full_help_description="",
+            use_case_description=[],
+        ),
+        supported_modes=set(Mode),
+        abbreviations=[],
+        name="__macro",
+        shortest_valid_string="",
+        snake_case_name="__macro",
+        camel_case_name="__Macro",
+        valid_argument_types=[[object, ...]]
+    )
+
+    @classmethod
+    @property
+    def time_command(cls) -> Command:
+        return cls._time_command
+
+    @classmethod
+    @property
+    def date_command(cls) -> Command:
+        return cls._date_command
+
+    @classmethod
+    @property
+    def macro_execute_command(cls) -> Command:
+        return cls._macro_execute_command
+
+    @classmethod
+    @property
+    def commands(cls) -> list[Command]:
+        if len(cls._commands) == 0:
+            cls._commands = CommandInitializer.initialize_commands(_global_command_templates)
+        return cls._commands
+
+    @classmethod
+    def get_command_by_name(cls, name: str) -> Command | None:
+        filtered_commands: list[Command] = [command for command in cls.commands if command.name == name]
+        command_found: bool = len(filtered_commands) == 1
+        if command_found:
+            return filtered_commands[0]
+        else:
+            return None