argenta 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

argenta/app/entity.py

@@ -1,4 +1,7 @@
 from typing import Callable
+from ..command.entity import Command
+from argenta.command.input_comand.entity import InputCommand
+from argenta.command.input_comand.exceptions import InvalidInputFlagException
 from ..router.entity import Router
 from .exceptions import (InvalidRouterInstanceException,
                          InvalidDescriptionMessagePatternException,
@@ -16,6 +19,7 @@ class App:
                  prompt: str = 'Enter a command',
                  initial_message: str = '\nHello, I am Argenta\n',
                  farewell_message: str = '\nGoodBye\n',
+                 invalid_input_flags_message: str = 'Invalid input flags',
                  exit_command: str = 'Q',
                  exit_command_description: str = 'Exit command',
                  exit_command_title: str = 'System points:',
@@ -33,13 +37,14 @@ class App:
         self.ignore_exit_command_register = ignore_exit_command_register
         self.farewell_message = farewell_message
         self.initial_message = initial_message
+        self.invalid_input_flags_message = invalid_input_flags_message
         self.line_separate = line_separate
         self.command_group_description_separate = command_group_description_separate
         self.ignore_command_register = ignore_command_register
         self.repeat_command_groups = repeat_command_groups
 
         self._routers: list[Router] = []
-        self._registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | str]] | Router]] = []
+        self._registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | Command]] | Router]] = []
         self._app_main_router: Router | None = None
         self._description_message_pattern: str = '[{command}] *=*=* {description}'
 
@@ -61,19 +66,27 @@ class App:
                 self._print_command_group_description()
                 self.print_func(self.prompt)
 
-            command: str = input()
+            raw_command: str = input()
+            try:
+                input_command: InputCommand = InputCommand.parse(raw_command=raw_command)
+            except InvalidInputFlagException:
+                self.print_func(self.line_separate)
+                self.print_func(self.command_group_description_separate)
+                if not self.repeat_command_groups:
+                    self.print_func(self.prompt)
+                continue
 
-            self._checking_command_for_exit_command(command)
+            self._checking_command_for_exit_command(input_command.get_string_entity())
             self.print_func(self.line_separate)
 
-            is_unknown_command: bool = self._check_is_command_unknown(command)
+            is_unknown_command: bool = self._check_is_command_unknown(input_command.get_string_entity())
             if is_unknown_command:
                 if not self.repeat_command_groups:
                     self.print_func(self.prompt)
                 continue
 
             for router in self._routers:
-                router.input_command_handler(command)
+                router.input_command_handler(input_command)
 
             self.print_func(self.line_separate)
             self.print_func(self.command_group_description_separate)
@@ -124,7 +137,7 @@ class App:
         router.set_ignore_command_register(self.ignore_command_register)
         self._routers.append(router)
 
-        command_entities: list[dict[str, Callable[[], None] | str]] = router.get_command_entities()
+        command_entities: list[dict[str, Callable[[], None] | Command]] = router.get_command_entities()
         self._registered_router_entities.append({'name': router.get_name(),
                                                  'title': router.get_title(),
                                                  'entity': router,
@@ -151,11 +164,11 @@ class App:
                 router.set_router_as_main()
                 self._app_main_router = router
 
-        if not self._app_main_router.unknown_command_func:
+        if not self._app_main_router.get_unknown_command_func():
             raise MissingHandlerForUnknownCommandsException()
 
         for router in self._routers:
-            if router.unknown_command_func and self._app_main_router is not router:
+            if router.get_unknown_command_func() and self._app_main_router is not router:
                 raise HandlerForUnknownCommandsOnNonMainRouterException()
 
 
@@ -187,14 +200,14 @@ class App:
 
 
     def _check_is_command_unknown(self, command: str):
-        registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | str]] | Router]] = self._registered_router_entities
+        registered_router_entities: list[dict[str, str | list[dict[str, Callable[[], None] | Command]] | Router]] = self._registered_router_entities
         for router_entity in registered_router_entities:
             for command_entity in router_entity['commands']:
-                if command_entity['command'].lower() == command.lower():
+                if command_entity['command'].get_string_entity().lower() == command.lower():
                     if self.ignore_command_register:
                         return False
                     else:
-                        if command_entity['command'] == command:
+                        if command_entity['command'].get_string_entity() == command:
                             return False
         self._app_main_router.unknown_command_handler(command)
         self.print_func(self.line_separate)
@@ -207,8 +220,8 @@ class App:
             self.print_func(router_entity['title'])
             for command_entity in router_entity['commands']:
                 self.print_func(self._description_message_pattern.format(
-                        command=command_entity['command'],
-                        description=command_entity['description']
+                        command=command_entity['command'].get_string_entity(),
+                        description=command_entity['command'].get_description()
                     )
                 )
             self.print_func(self.command_group_description_separate)

argenta/command/entity.py

@@ -0,0 +1,60 @@
+from .params.flag.entity import Flag
+from .params.flag.flags_group.entity import FlagsGroup
+from .exceptions import (InvalidCommandInstanceException,
+                         InvalidDescriptionInstanceException,
+                         InvalidFlagsInstanceException)
+from .params.flag.input_flag.entity import InputFlag
+
+
+class Command:
+    def __init__(self, command: str,
+                 description: str | None = None,
+                 flags: Flag | FlagsGroup | None = None):
+        self._command = command
+        self._description = description
+        self._flags: FlagsGroup | None = flags if isinstance(flags, FlagsGroup) else FlagsGroup([flags]) if isinstance(flags, Flag) else flags
+
+        self._input_flags: InputFlag | FlagsGroup | None = None
+
+    def get_string_entity(self):
+        return self._command
+
+    def get_description(self):
+        if not self._description:
+            description = f'description for "{self._command}" command'
+            return description
+        else:
+            return self._description
+
+    def get_flags(self):
+        return self._flags
+
+    def set_command(self, command: str):
+        self._command = command
+
+    def validate_commands_params(self):
+        if not isinstance(self._command, str):
+            raise InvalidCommandInstanceException(self._command)
+        if not isinstance(self._description, str):
+            raise InvalidDescriptionInstanceException()
+        if not any([(isinstance(self._flags, Flag), isinstance(self._flags, FlagsGroup)), not self._flags]):
+            raise InvalidFlagsInstanceException
+
+    def validate_input_flag(self, flag: InputFlag):
+        registered_flags: FlagsGroup | Flag | None = self._flags
+        if registered_flags:
+            if isinstance(registered_flags, Flag):
+                if registered_flags.get_string_entity() == flag.get_string_entity():
+                    is_valid = registered_flags.validate_input_flag_value(flag.get_value())
+                    if is_valid:
+                        return True
+            else:
+                for registered_flag in registered_flags:
+                    if registered_flag.get_string_entity() == flag.get_string_entity():
+                        is_valid = registered_flag.validate_input_flag_value(flag.get_value())
+                        if is_valid:
+                            return True
+        return False
+
+
+

argenta/command/exceptions.py

@@ -0,0 +1,13 @@
+class InvalidCommandInstanceException(Exception):
+    def __str__(self):
+        return "Invalid Command Instance"
+
+
+class InvalidDescriptionInstanceException(Exception):
+    def __str__(self):
+        return "Invalid Description Instance"
+
+
+class InvalidFlagsInstanceException(Exception):
+    def __str__(self):
+        return "Invalid Flags Instance"

argenta/command/input_comand/entity.py

@@ -0,0 +1,66 @@
+from ..input_comand.exceptions import IncorrectInputFlagException, RepeatedInputFlagsException
+from ..entity import Command
+from ..params.flag.flags_group.entity import FlagsGroup
+from ..params.flag.input_flag.entity import InputFlag
+
+from typing import Generic, TypeVar
+
+
+T = TypeVar('T')
+
+
+class InputCommand(Command, Generic[T]):
+    def set_input_flags(self, input_flags: FlagsGroup):
+        self._input_flags = input_flags
+
+    def get_input_flags(self) -> FlagsGroup:
+        return self._input_flags
+
+    @staticmethod
+    def parse(raw_command: str) -> 'InputCommand[T]':
+        list_of_tokens = raw_command.split()
+        command = list_of_tokens[0]
+        list_of_tokens.pop(0)
+
+        flags: FlagsGroup = FlagsGroup()
+        current_flag_name = None
+        current_flag_value = None
+        for _ in list_of_tokens:
+            if _.startswith('-'):
+                flag_prefix_last_symbol_index = _.rfind('-')
+                if current_flag_name or len(_) < 2 or len(_[:flag_prefix_last_symbol_index]) > 3:
+                    raise IncorrectInputFlagException()
+                else:
+                    current_flag_name = _
+            else:
+                if not current_flag_name:
+                    raise IncorrectInputFlagException()
+                else:
+                    current_flag_value = _
+            if current_flag_name and current_flag_value:
+                flag_prefix_last_symbol_index = current_flag_name.rfind('-')
+                flag_prefix = current_flag_name[:flag_prefix_last_symbol_index]
+                flag_name = current_flag_name[flag_prefix_last_symbol_index:]
+
+                input_flag = InputFlag(flag_name=flag_name,
+                                       flag_prefix=flag_prefix)
+                input_flag.set_value(current_flag_value)
+
+                all_flags = [x.get_string_entity() for x in flags.get_flags()]
+                if input_flag.get_string_entity() not in all_flags:
+                    flags.add_flag(input_flag)
+                else:
+                    raise RepeatedInputFlagsException(input_flag)
+
+                current_flag_name = None
+                current_flag_value = None
+        if any([current_flag_name, current_flag_value]):
+            raise IncorrectInputFlagException()
+        if len(flags.get_flags()) == 0:
+            return InputCommand(command=command)
+        else:
+            input_command = InputCommand(command=command)
+            input_command.set_input_flags(flags)
+            return input_command
+
+

argenta/command/input_comand/exceptions.py

@@ -0,0 +1,24 @@
+from ..params.flag.input_flag.entity import InputFlag
+
+
+class InvalidInputFlagException(Exception):
+    def __init__(self, flag: InputFlag):
+        self.flag = flag
+    def __str__(self):
+        return ("Invalid Input Flags\n"
+                f"Unknown or invalid input flag: '{self.flag.get_string_entity()} {self.flag.get_value()}'")
+
+class IncorrectInputFlagException(Exception):
+    def __str__(self):
+        return "Incorrect Input Flags"
+
+
+class RepeatedInputFlagsException(Exception):
+    def __init__(self, flag: InputFlag):
+        self.flag = flag
+    def __str__(self):
+        return ("Repeated Input Flags\n"
+                f"Duplicate flag was detected in the input: '{self.flag.get_string_entity()}'")
+
+
+

argenta/command/params/flag/entity.py

@@ -0,0 +1,45 @@
+from typing import Literal
+
+
+class Flag:
+    def __init__(self, flag_name: str,
+                 flag_prefix: Literal['-', '--', '---'] = '-',
+                 ignore_flag_value_register: bool = False,
+                 possible_flag_values: list[str] = False):
+        self._flag_name = flag_name
+        self._flag_prefix = flag_prefix
+        self.possible_flag_values = possible_flag_values
+        self.ignore_flag_value_register = ignore_flag_value_register
+
+        self._value = None
+
+    def get_string_entity(self):
+        string_entity: str = self._flag_prefix + self._flag_name
+        return string_entity
+
+    def get_flag_name(self):
+        return self._flag_name
+
+    def get_flag_prefix(self):
+        return self._flag_prefix
+
+    def get_value(self):
+        return self._value
+
+    def set_value(self, value):
+        self._value = value
+
+    def validate_input_flag_value(self, input_flag_value: str):
+        if self.possible_flag_values:
+            if self.ignore_flag_value_register:
+                if input_flag_value.lower() in [x.lower() for x in self.possible_flag_values]:
+                    return True
+                else:
+                    return False
+            else:
+                if input_flag_value in self.possible_flag_values:
+                    return True
+                else:
+                    return False
+        else:
+            return True

argenta/command/params/flag/flags_group/entity.py

@@ -0,0 +1,22 @@
+from argenta.command.params.flag.entity import Flag
+from argenta.command.params.flag.input_flag.entity import InputFlag
+
+
+class FlagsGroup:
+    def __init__(self, flags: list[Flag | InputFlag] = None):
+        self._flags: list[Flag | InputFlag] = [] if not flags else flags
+
+    def get_flags(self):
+        return self._flags
+
+    def add_flag(self, flag: Flag | InputFlag):
+        self._flags.append(flag)
+
+    def add_flags(self, flags: list[Flag | InputFlag]):
+        self._flags.extend(flags)
+
+    def __iter__(self):
+        return iter(self._flags)
+
+    def __next__(self):
+        return next(iter(self))

argenta/command/params/flag/input_flag/entity.py

@@ -0,0 +1,11 @@
+from ...flag.entity import Flag
+
+
+class InputFlag(Flag):
+    def set_value(self, value: str):
+        self._value = value
+
+    def get_value(self) -> str:
+        return self._value
+
+

argenta/router/__init__.py

@@ -1,4 +1,3 @@
 from .entity import Router
 from .exceptions import (UnknownCommandHandlerHasAlreadyBeenCreatedException,
-                         InvalidDescriptionInstanceException,
-                         InvalidCommandInstanceException)
+                         InvalidDescriptionInstanceException)

argenta/router/entity.py

@@ -1,8 +1,10 @@
 from typing import Callable, Any
-from ..router.exceptions import (InvalidCommandInstanceException,
-                                 UnknownCommandHandlerHasAlreadyBeenCreatedException,
-                                 InvalidDescriptionInstanceException,
-                                 RepeatedCommandException)
+from ..command.entity import Command
+from ..command.input_comand.entity import InputCommand
+from ..command.input_comand.exceptions import InvalidInputFlagException
+from ..command.params.flag.flags_group.entity import FlagsGroup
+from ..router.exceptions import (UnknownCommandHandlerHasAlreadyBeenCreatedException,
+                                 RepeatedCommandException, RepeatedFlagNameException)
 
 
 class Router:
@@ -13,20 +15,19 @@ class Router:
         self.title = title
         self.name = name
 
-        self._command_entities: list[dict[str, Callable[[], None] | str]] = []
-        self.unknown_command_func: Callable[[str], None] | None = None
+        self._command_entities: list[dict[str, Callable[[], None] | Command]] = []
+        self._unknown_command_func: Callable[[str], None] | None = None
         self._is_main_router: bool = False
-        self.ignore_command_register: bool = False
+        self._ignore_command_register: bool = False
 
 
-    def command(self, command: str, description: str = None) -> Callable[[Any],  Any]:
-        processed_description = Router._validate_description(command, description)
+    def command(self, command: Command) -> Callable[[Any],  Any]:
+        command.validate_commands_params()
         self._validate_command(command)
 
         def command_decorator(func):
             self._command_entities.append({'handler_func': func,
-                                           'command': command,
-                                           'description': processed_description})
+                                           'command': command})
             def wrapper(*args, **kwargs):
                 return func(*args, **kwargs)
             return wrapper
@@ -35,48 +36,62 @@ class Router:
 
 
     def unknown_command(self, func):
-        if self.unknown_command_func is not None:
+        if self._unknown_command_func is not None:
             raise UnknownCommandHandlerHasAlreadyBeenCreatedException()
 
-        self.unknown_command_func: Callable = func
+        self._unknown_command_func: Callable = func
 
         def wrapper(*args, **kwargs):
             return func(*args, **kwargs)
         return wrapper
 
 
-    def input_command_handler(self, input_command):
+    def input_command_handler(self, input_command: InputCommand):
+        input_command_name: str = input_command.get_string_entity()
         for command_entity in self._command_entities:
-            if input_command.lower() == command_entity['command'].lower():
-                if self.ignore_command_register:
-                    return command_entity['handler_func']()
-                else:
-                    if input_command == command_entity['command']:
+            if input_command_name.lower() == command_entity['command'].get_string_entity().lower():
+                if self._ignore_command_register:
+                    if input_command.get_input_flags():
+                        for flag in input_command.get_input_flags():
+                            is_valid = command_entity['command'].validate_input_flag(flag)
+                            if not is_valid:
+                                raise InvalidInputFlagException(flag)
+                        return command_entity['handler_func'](input_command.get_input_flags())
+                    else:
                         return command_entity['handler_func']()
+                else:
+                    if input_command_name == command_entity['command'].get_string_entity():
+                        if input_command.get_input_flags():
+                            for flag in input_command.get_input_flags():
+                                is_valid = command_entity['command'].validate_input_flag(flag)
+                                if not is_valid:
+                                    raise InvalidInputFlagException(flag)
+                            return command_entity['handler_func'](input_command.get_input_flags())
+                        else:
+                            return command_entity['handler_func']()
+
+
+    def get_unknown_command_func(self):
+        return self._unknown_command_func
 
 
     def unknown_command_handler(self, unknown_command):
-        self.unknown_command_func(unknown_command)
+        self._unknown_command_func(unknown_command)
 
 
-    def _validate_command(self, command: str):
-        if not isinstance(command, str):
-            raise InvalidCommandInstanceException()
-        if command in self.get_all_commands():
+    def _validate_command(self, command: Command):
+        command_name: str = command.get_string_entity()
+        if command_name in self.get_all_commands():
             raise RepeatedCommandException()
-        if self.ignore_command_register:
-            if command.lower() in [x.lower() for x in self.get_all_commands()]:
+        if self._ignore_command_register:
+            if command_name.lower() in [x.lower() for x in self.get_all_commands()]:
                 raise RepeatedCommandException()
 
-
-    @staticmethod
-    def _validate_description(command: str, description: str):
-        if not isinstance(description, str):
-            if description is None:
-                description = f'description for "{command}" command'
-            else:
-                raise InvalidDescriptionInstanceException()
-        return description
+        flags: FlagsGroup = command.get_flags()
+        if flags:
+            flags_name: list = [x.get_string_entity().lower() for x in flags]
+            if len(set(flags_name)) < len(flags_name):
+                raise RepeatedFlagNameException()
 
 
     def set_router_as_main(self):
@@ -86,10 +101,10 @@ class Router:
 
 
     def set_ignore_command_register(self, ignore_command_register: bool):
-        self.ignore_command_register = ignore_command_register
+        self._ignore_command_register = ignore_command_register
 
 
-    def get_command_entities(self) -> list[dict[str, Callable[[], None] | str]]:
+    def get_command_entities(self) -> list[dict[str, Callable[[], None] | Command]]:
         return self._command_entities
 
 
@@ -105,10 +120,10 @@ class Router:
         return {
             'title': self.title,
             'name': self.name,
-            'ignore_command_register': self.ignore_command_register,
+            'ignore_command_register': self._ignore_command_register,
             'attributes': {
                 'command_entities': self._command_entities,
-                'unknown_command_func': self.unknown_command_func,
+                'unknown_command_func': self._unknown_command_func,
                 'is_main_router': self._is_main_router
             }
 
@@ -118,6 +133,13 @@ class Router:
     def get_all_commands(self) -> list[str]:
         all_commands: list[str] = []
         for command_entity in self._command_entities:
-            all_commands.append(command_entity['command'])
+            all_commands.append(command_entity['command'].get_string_entity())
 
         return all_commands
+
+    def get_all_flags(self) -> list[FlagsGroup]:
+        all_flags: list[FlagsGroup] = []
+        for command_entity in self._command_entities:
+            all_flags.append(command_entity['command'].get_flags())
+
+        return all_flags

argenta/router/exceptions.py

@@ -1,8 +1,3 @@
-class InvalidCommandInstanceException(Exception):
-    def __str__(self):
-        return "Invalid Command Instance"
-
-
 class InvalidDescriptionInstanceException(Exception):
     def __str__(self):
         return "Invalid Description Instance"
@@ -16,3 +11,8 @@ class UnknownCommandHandlerHasAlreadyBeenCreatedException(Exception):
 class RepeatedCommandException(Exception):
     def __str__(self):
         return "Commands in handler cannot be repeated"
+
+
+class RepeatedFlagNameException(Exception):
+    def __str__(self):
+        return "Repeated flag name in register command"

{argenta-0.2.2.dist-info → argenta-0.3.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.3
 Name: argenta
-Version: 0.2.2
-Summary: python library for creating cli apps
+Version: 0.3.0
+Summary: python library for creating custom shells
 License: MIT
 Author: kolo
 Author-email: kolo.is.main@gmail.com

argenta-0.3.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+argenta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/app/__init__.py,sha256=jXP3ishSp3fF7fePZOtd_LAbBfn_RuNwnGidpk9H-74,415
+argenta/app/entity.py,sha256=GdcqloQoShiCRv9GahWJfV4F_pCcK3bGFkVPoj3AnrQ,10468
+argenta/app/exceptions.py,sha256=8p8_ucklfmHlUPaiMS7D_026laep-fr4bTXdRRJtB_k,2030
+argenta/command/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/command/entity.py,sha256=9FkU_NbI1WsXrnKA1Ba86xwYoRwLLdk81yI9dj7RsF8,2451
+argenta/command/exceptions.py,sha256=qTt3G0XaWW5BBQyxNkVWFY0SMGn92VuxvSRs0G37lHI,366
+argenta/command/input_comand/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/command/input_comand/entity.py,sha256=YyJPMV8Hy1QSgvgu_w9cjWdiQ2JXG21EbCabns4w_ek,2585
+argenta/command/input_comand/exceptions.py,sha256=rVFOMkF-8ItwAs_JXofAZG3aTQvdn11SwJ3d39hH-4k,748
+argenta/command/params/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/command/params/flag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/command/params/flag/entity.py,sha256=gUax6hkuSuarH8yQwFC4QsGql8n1POi19Ww4yEh2c2k,1446
+argenta/command/params/flag/flags_group/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/command/params/flag/flags_group/entity.py,sha256=aFbo5mzevuDxVb8VpaRCUSgUCLn6GK-ODCz5N5650Q8,638
+argenta/command/params/flag/input_flag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argenta/command/params/flag/input_flag/entity.py,sha256=KHoZRE7pRc30LyS6yF_7G7IrA8DrH-gS-Hg_qNstkzU,195
+argenta/router/__init__.py,sha256=RvVORE4g0uIWWuQHav0KK-I7AlCuXW4HeW-8MW7fOyo,168
+argenta/router/entity.py,sha256=0kx6iDa3rOe5Zr7TB3BpXjpDJqy-gjfqtdYJsitVJy0,5587
+argenta/router/exceptions.py,sha256=np8hclunhbyt9E2oZym3g9-5a6UpEj9s_52OR6QA56s,551
+argenta-0.3.0.dist-info/LICENSE,sha256=zmqoGh2n5rReBv4s8wPxF_gZEZDgauJYSPMuPczgOiU,1082
+argenta-0.3.0.dist-info/METADATA,sha256=qpC9EWXrK66dlv02BMHGIwaYTaYVkNdzbaVNa7q78BE,12638
+argenta-0.3.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+argenta-0.3.0.dist-info/RECORD,,

argenta-0.2.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-argenta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-argenta/app/__init__.py,sha256=jXP3ishSp3fF7fePZOtd_LAbBfn_RuNwnGidpk9H-74,415
-argenta/app/entity.py,sha256=IRO3YMZvq-QGcxnB3TcZKOf8AIyh7ttYFCeQoagLwTM,9570
-argenta/app/exceptions.py,sha256=8p8_ucklfmHlUPaiMS7D_026laep-fr4bTXdRRJtB_k,2030
-argenta/router/__init__.py,sha256=gjneUFVbKVgwil8TbHRvCN89wT_U9CaakSbFmMC_fxk,227
-argenta/router/entity.py,sha256=1cI8I2ps6ZaiDZJ8Vt2PDAsVjaWPPdSVHfZk11KAPdY,4266
-argenta/router/exceptions.py,sha256=fgJEsMfdN6sjbfie8Ea9jbopF7HKQi-6vKCCRQrVlTA,543
-argenta-0.2.2.dist-info/LICENSE,sha256=zmqoGh2n5rReBv4s8wPxF_gZEZDgauJYSPMuPczgOiU,1082
-argenta-0.2.2.dist-info/METADATA,sha256=fIyfYSxGsXrE2yKITAJ52_Ocs5H0Fs2DubrKjG5W5DI,12633
-argenta-0.2.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-argenta-0.2.2.dist-info/RECORD,,