argenta 0.5.0b2__py3-none-any.whl → 1.0.0__py3-none-any.whl

argenta/app/autocompleter/entity.py

@@ -1,24 +1,44 @@
 import os
 import readline
+from typing import Never
 
 
 class AutoCompleter:
-    def __init__(self, history_filename: str = False, autocomplete_button: str = 'tab'):
+    def __init__(
+        self, history_filename: str = False, autocomplete_button: str = "tab"
+    ) -> None:
+        """
+        Public. Configures and implements auto-completion of input command
+        :param history_filename: the name of the file for saving the history of the autocompleter
+        :param autocomplete_button: the button for auto-completion
+        :return: None
+        """
         self.history_filename = history_filename
         self.autocomplete_button = autocomplete_button
-        self.matches = []
 
-    def complete(self, text, state):
-        matches = sorted(cmd for cmd in self.get_history_items() if cmd.startswith(text))
+    def _complete(self, text, state) -> str | None:
+        """
+        Private. Auto-completion function
+        :param text: part of the command being entered
+        :param state: the current cursor position is relative to the beginning of the line
+        :return: the desired candidate as str or None
+        """
+        matches: list[str] = sorted(
+            cmd for cmd in self.get_history_items() if cmd.startswith(text)
+        )
         if len(matches) > 1:
             common_prefix = matches[0]
             for match in matches[1:]:
                 i = 0
-                while i < len(common_prefix) and i < len(match) and common_prefix[i] == match[i]:
+                while (
+                    i < len(common_prefix)
+                    and i < len(match)
+                    and common_prefix[i] == match[i]
+                ):
                     i += 1
                 common_prefix = common_prefix[:i]
             if state == 0:
-                readline.insert_text(common_prefix[len(text):])
+                readline.insert_text(common_prefix[len(text) :])
                 readline.redisplay()
             return None
         elif len(matches) == 1:
@@ -26,7 +46,12 @@ class AutoCompleter:
         else:
             return None
 
-    def initial_setup(self, all_commands: list[str]):
+    def initial_setup(self, all_commands: list[str]) -> None:
+        """
+        Private. Initial setup function
+        :param all_commands: Registered commands for adding them to the autocomplete history
+        :return: None
+        """
         if self.history_filename:
             if os.path.exists(self.history_filename):
                 readline.read_history_file(self.history_filename)
@@ -34,14 +59,33 @@ class AutoCompleter:
                 for line in all_commands:
                     readline.add_history(line)
 
-        readline.set_completer(self.complete)
-        readline.set_completer_delims(readline.get_completer_delims().replace(' ', ''))
-        readline.parse_and_bind(f'{self.autocomplete_button}: complete')
+        readline.set_completer(self._complete)
+        readline.set_completer_delims(readline.get_completer_delims().replace(" ", ""))
+        readline.parse_and_bind(f"{self.autocomplete_button}: complete")
 
-    def exit_setup(self):
+    def exit_setup(self, all_commands: list[str]) -> None:
+        """
+        Private. Exit setup function
+        :return: None
+        """
         if self.history_filename:
             readline.write_history_file(self.history_filename)
+            with open(self.history_filename, "r") as history_file:
+                raw_history = history_file.read()
+            pretty_history: list[str] = []
+            for line in set(raw_history.strip().split("\n")):
+                if line.split()[0] in all_commands:
+                    pretty_history.append(line)
+            with open(self.history_filename, "w") as history_file:
+                history_file.write("\n".join(pretty_history))
 
     @staticmethod
-    def get_history_items():
-        return [readline.get_history_item(i) for i in range(1, readline.get_current_history_length() + 1)]
+    def get_history_items() -> list[str] | list[Never]:
+        """
+        Private. Returns a list of all commands entered by the user
+        :return: all commands entered by the user as list[str] | list[Never]
+        """
+        return [
+            readline.get_history_item(i)
+            for i in range(1, readline.get_current_history_length() + 1)
+        ]

argenta/app/defaults.py

@@ -2,8 +2,11 @@ from dataclasses import dataclass
 
 
 @dataclass
-class PredeterminedMessages:
-    USAGE = '[b dim]Usage[/b dim]: [i]<command> <[green]flags[/green]>[/i]'
-    HELP = '[b dim]Help[/b dim]: [i]<command>[/i] [b red]--help[/b red]'
-    AUTOCOMPLETE = '[b dim]Autocomplete[/b dim]: [i]<part>[/i] [bold]<tab>'
+class PredefinedMessages:
+    """
+    Public. A dataclass with predetermined messages for quick use
+    """
 
+    USAGE = "[b dim]Usage[/b dim]: [i]<command> <[green]flags[/green]>[/i]"
+    HELP = "[b dim]Help[/b dim]: [i]<command>[/i] [b red]--help[/b red]"
+    AUTOCOMPLETE = "[b dim]Autocomplete[/b dim]: [i]<part>[/i] [bold]<tab>"

argenta/app/dividing_line/models.py

@@ -1,24 +1,66 @@
-class BaseDividingLine:
-    def __init__(self, unit_part: str = '-'):
-        self.unit_part = unit_part
+from abc import ABC
 
-    def get_unit_part(self):
-        if len(self.unit_part) == 0:
-            return ' '
+
+class BaseDividingLine(ABC):
+    def __init__(self, unit_part: str = "-") -> None:
+        """
+        Private. The basic dividing line
+        :param unit_part: the single part of the dividing line
+        :return: None
+        """
+        self._unit_part = unit_part
+
+    def get_unit_part(self) -> str:
+        """
+        Private. Returns the unit part of the dividing line
+        :return: unit_part of dividing line as str
+        """
+        if len(self._unit_part) == 0:
+            return " "
         else:
-            return self.unit_part[0]
+            return self._unit_part[0]
+
 
 class StaticDividingLine(BaseDividingLine):
-    def __init__(self, unit_part: str = '-', length: int = 25):
+    def __init__(self, unit_part: str = "-", length: int = 25) -> None:
+        """
+        Public. The static dividing line
+        :param unit_part: the single part of the dividing line
+        :param length: the length of the dividing line
+        :return: None
+        """
         super().__init__(unit_part)
         self.length = length
 
-    def get_full_line(self):
-        return f'\n[dim]{self.length * self.get_unit_part()}[/dim]\n'
+    def get_full_static_line(self, is_override: bool) -> str:
+        """
+        Private. Returns the full line of the dividing line
+        :param is_override: has the default text layout been redefined
+        :return: full line of dividing line as str
+        """
+        if is_override:
+            return f"\n{self.length * self.get_unit_part()}\n"
+        else:
+            return f"\n[dim]{self.length * self.get_unit_part()}[/dim]\n"
 
 
 class DynamicDividingLine(BaseDividingLine):
-    def get_full_line(self, length: int):
-        return f'\n[dim]{self.get_unit_part() * length}[/dim]\n'
-
+    def __init__(self, unit_part: str = "-") -> None:
+        """
+        Public. The dynamic dividing line
+        :param unit_part: the single part of the dividing line
+        :return: None
+        """
+        super().__init__(unit_part)
 
+    def get_full_dynamic_line(self, length: int, is_override: bool) -> str:
+        """
+        Private. Returns the full line of the dividing line
+        :param length: the length of the dividing line
+        :param is_override: has the default text layout been redefined
+        :return: full line of dividing line as str
+        """
+        if is_override:
+            return f"\n{length * self.get_unit_part()}\n"
+        else:
+            return f"\n[dim]{self.get_unit_part() * length}[/dim]\n"