anb-python-components 1.2.1__py3-none-any.whl

anb_python_components/extensions/bool_extension.py

@@ -0,0 +1,87 @@
+# anb_python_components/extensions/bool_extension.py
+
+from anb_python_components.enums.not_bool_action import NotBoolAction
+
+class BoolExtension:
+    """
+    Расширение типа "правда/ложь".
+    """
+    
+    def __init__ (self):
+        """
+        Инициализация расширения.
+        """
+        pass
+    
+    @staticmethod
+    def to_str (b: bool, if_true: str = "True", if_false: str = "False") -> str:
+        """
+        Конвертирует булево значение в строку.
+        :param b: Булево значение.
+        :param if_true: Возвращаемое значение, если b == True (по умолчанию "True")
+        :param if_false: Возвращаемое значение, если b == False (по умолчанию "False")
+        :return: Строка, соответствующая булевому значению.
+        """
+        return if_true if b else if_false
+    
+    @staticmethod
+    def true_count (expressions: list[bool], if_not_bool: NotBoolAction = NotBoolAction.IGNORE) -> int:
+        """
+        Возвращает количество истинных значений в списке аргументов.
+        :param expressions: Список аргументов.
+        :param if_not_bool: Действие при не булевом значении.
+        :return: Количество истинных значений в списке аргументов.
+        """
+        # Создаем пустой массив для хранения проверяемых аргументов
+        check_array = []
+        
+        # Проверяем все входящие аргументы
+        for expression in expressions:
+            # - если аргумент не является типом правда/ложь
+            if not isinstance(expression, bool):
+                match if_not_bool:
+                    # -- если указано действие при не булевом значении - игнорирование
+                    case NotBoolAction.IGNORE:
+                        # - игнорируем аргумент и продолжаем цикл
+                        continue
+                    
+                    # -- если указано действие при не булевом значении - считать как истинное значение
+                    case NotBoolAction.IT_TRUE:
+                        # --- добавляем True в массив проверяемых аргументов
+                        check_array.append(True)
+                        # --- и продолжаем цикл
+                        continue
+                    
+                    # -- если указано действие при не булевом значении - считать как ложное значение
+                    case NotBoolAction.IT_FALSE:
+                        # --- добавляем False в массив проверяемых аргументов
+                        check_array.append(False)
+                        # --- и продолжаем цикл
+                        continue
+                    
+                    # -- если указано действие при не булевом значении - выбросить исключение
+                    case NotBoolAction.RAISE:
+                        # --- то вызываем исключение
+                        raise ValueError(f"{expression} не является булевым значением")
+            else:
+                # - иначе добавляем аргумент в массив проверяемых аргументов
+                check_array.append(expression)
+        
+        # Используем фильтрацию массива для получения массива только истинных значений
+        filtered = [value for value in check_array if value]
+        
+        # Возвращаем количество истинных значений в отфильтрованном массиве
+        return len(filtered)
+    
+    @staticmethod
+    def any_true (expressions: list[bool]) -> bool:
+        """
+        Проверяет, есть ли хотя бы один истинный аргумент.
+        :param expressions: Выражения.
+        :return: Есть ли хотя бы один истинный аргумент, то вернется True, иначе False.
+        """
+        # Получаем количество истинных значений
+        true_count = BoolExtension.true_count(expressions, NotBoolAction.IGNORE)
+        
+        # Если количество истинных значений больше нуля, возвращаем True, иначе False
+        return True if true_count > 0 else False

anb_python_components/extensions/string_extension.py

@@ -0,0 +1,259 @@
+# anb_python_components/extensions/string_extension.py
+import re
+
+from .string_extension_constant import StringExtensionConstants
+
+class StringExtension:
+    """
+    Расширение строк.
+    """
+    
+    def __init__ (self):
+        """
+        Конструктор.
+        """
+        pass
+    
+    @staticmethod
+    def is_none_or_empty (text: str | None) -> bool:
+        """
+        Проверяет, пуста ли строка.
+        :param text: Проверяемая строка.
+        :return: Результат проверки.
+        """
+        return text is None or text == ""
+    
+    @classmethod
+    def is_none_or_whitespace (cls, text: str | None) -> bool:
+        """
+        Проверяет, пуста ли строка, содержит ли вместо текста только пробелы.
+        :param text: Проверяемая строка.
+        :return: Bool Результат проверки.
+        """
+        return cls.is_none_or_empty(text) or text.strip() == ''
+    
+    @staticmethod
+    def is_russian_letter (letter: str) -> bool:
+        """
+        Проверяет, является ли символ русским буквой.
+        :param letter: Проверяемый символ.
+        :return: Результат проверки.
+        """
+        
+        return letter in StringExtensionConstants.russian_letters
+    
+    @staticmethod
+    def get_russian_letter_transliteration (letter: str) -> bool | None:
+        """
+        Получаю транслитерированную букву русского алфавита.
+        :param letter: Буква русского алфавита.
+        :return: Транслитерированная буква.
+        """
+        
+        try:
+            # Получаю транслитерированную букву
+            transliteration = StringExtensionConstants.russian_letters[letter]
+            
+            # Если не удалось получить транслитерированную букву
+            if transliteration is None:
+                # - то возбуждаю исключение
+                raise KeyError
+        except KeyError:
+            # Если возбуждено исключение, то возвращаю None
+            return None
+        
+        # Возвращаю транслитерированную букву
+        return transliteration
+    
+    @classmethod
+    def convert_to_latin (cls, source: str) -> str:
+        """
+        Конвертация в латиницу.
+        :param source: Исходная строка.
+        :return: Результат перевода.
+        """
+        # Создаю результат
+        result = ""
+        
+        # Получаю длину строкиДля каждой буквы или символа из слова
+        for i, letter in enumerate(source):
+            if cls.is_russian_letter(letter):
+                # - транслитерирую эту букву
+                result_transliteration = cls.get_russian_letter_transliteration(letter)
+                
+                # - если транслитерация не удалась
+                if result_transliteration is None:
+                    # -- вывожу оригинальную букву
+                    result += letter
+                else:
+                    # -- вывожу транслитерированную букву
+                    result += result_transliteration
+            else:
+                # - иначе вывожу букву или символ
+                result += letter
+        
+        # Вывожу результат
+        return result
+    
+    @classmethod
+    def compare (cls, str1: str | None, str2: str | None, ignore_case: bool = False) -> int:
+        """
+        Сравнивает две строки.
+        :param str1: Первая строка.
+        :param str2: Вторая строка.
+        :param ignore_case: Нужно ли учитывать регистр (по умолчанию, нет).
+        :return: Результат сравнения. Возвращаемые значения:
+                    -1 | значение str1 меньше значения str2.
+                     0 | значения str1 и str2 равны.
+                     1 | значение str1 больше значения str2.
+        """
+        # Если обе строки пусты
+        if cls.is_none_or_whitespace(str1) and cls.is_none_or_whitespace(str2):
+            # - то считаем их равными
+            return 0
+        
+        # Если первый из них не пуст, а второй пуст
+        if not cls.is_none_or_whitespace(str1) and cls.is_none_or_whitespace(str2):
+            # - то первый больше
+            return 1
+        
+        # Если первый из них пуст, а второй не пуст
+        if cls.is_none_or_whitespace(str1) and not cls.is_none_or_whitespace(str2):
+            # - то первый меньше
+            return -1
+        
+        # Если не нужно учитывать регистр
+        # - преобразую (или нет) первую строку
+        compare_str_1 = str1 if not ignore_case else str1.lower()
+        # - преобразую (или нет) вторую строку
+        compare_str_2 = str2 if not ignore_case else str2.lower()
+        
+        # Проверяю равенство
+        if compare_str_1 == compare_str_2:
+            # - и если равны, то возвращаю 0
+            return 0
+        
+        # Они не равны, поэтому получим длину первого слова и второго
+        len1 = len(compare_str_1)
+        len2 = len(compare_str_2)
+        
+        # Если длина первого больше и равна второго, то верну 1, иначе -1
+        return 1 if len1 >= len2 else -1
+    
+    @staticmethod
+    def get_short_text (text: str, max_length: int, end_symbols: str = '') -> str:
+        """
+        Обрезает строку до указанных в параметре max_length символов.
+        :param text: Исходный текст.
+        :param max_length: Максимальная длина текста.
+        :param end_symbols: Суффикс, которым завершается обрезанная строка (по умолчанию, "").
+        :return: Обрезанный текст.
+        """
+        # Если длина текста меньше максимальной
+        if len(text) <= max_length:
+            # - то возвращаем сам текст
+            return text
+        
+        # Если длина текста больше максимальной, то получаю длину текста без суффикса
+        len_no_end_symbols = max_length - len(end_symbols)
+        
+        # Возвращаю обрезанный текст
+        return text[:len_no_end_symbols] + end_symbols
+    
+    @staticmethod
+    def to_utf8 (subject: str, encoding: str = 'UTF-8') -> str:
+        """
+        Перекодирует строку в UTF-8.
+        :param subject: Исходная строка.
+        :param encoding: Исходная кодировка (по умолчанию, UTF-8).
+        :return: Перекодированная строка.
+        """
+        # Если текущая кодировка уже UTF-8
+        if encoding == 'UTF-8':
+            # - то возвращаю исходную строку
+            return subject
+        
+        # Получаем байты оригинальной строки
+        bytes_original = subject.encode(encoding)
+        
+        # Преобразовываем в Unicode (используя указанную кодировку)
+        unicode_string = bytes_original.decode(encoding)
+        
+        # Кодируем в UTF-8
+        utf8_bytes = unicode_string.encode('UTF-8')
+        
+        # Возвращаем результат
+        return utf8_bytes.decode('UTF-8')
+    
+    @staticmethod
+    def from_utf8 (subject: str, to_encoding: str = 'UTF-8') -> str:
+        """
+        Перекодирует строку из UTF-8.
+        :param subject: Исходная строка.
+        :param to_encoding: Кодировка, в которую нужно перекодировать (по умолчанию, UTF-8).
+        :return: Перекодированная строка.
+        """
+        # Если нужно перекодировать в UTF-8
+        if to_encoding == 'UTF-8':
+            # - то возвращаю исходную строку
+            return subject
+        
+        # Получаю байты строки
+        target_bytes = subject.encode('UTF-8')
+        
+        # Преобразовываю в нужную кодировку и возвращаю результат
+        return str(target_bytes.decode('UTF-8').encode(to_encoding))
+    
+    @classmethod
+    def replace (cls, subject: str, search: str, replace: str, encoding: str = 'UTF-8') -> str:
+        """
+        Заменяет в строке все вхождения строки поиска на строку замены.
+        :param subject: Исходная строка.
+        :param search: Строка поиска.
+        :param replace: Строка замены.
+        :param encoding: Кодировка (по умолчанию, UTF-8).
+        :return: Результат замены.
+        """
+        # Если кодировка не UTF-8
+        if encoding != 'UTF-8':
+            # - то перекодируем строку поиска, замены и исходную строку в UTF-8
+            search = cls.to_utf8(search, encoding)
+            # - и перекодируем строку замены в UTF-8
+            replace = cls.to_utf8(replace, encoding)
+            # - и перекодируем исходную строку в UTF-8
+            subject = cls.to_utf8(subject, encoding)
+        
+        # Используем re.escape для экранирования спецсимволов
+        pattern = re.escape(search)
+        
+        # Замена всех вхождений search на replace
+        result = re.sub(pattern, replace, subject)
+        
+        # Если кодировка не UTF-8
+        if encoding != 'UTF-8':
+            # - то перекодируем результат в нужную кодировку
+            result = cls.from_utf8(result, encoding)
+        
+        # Возвращаем результат
+        return result
+    
+    @classmethod
+    def replace_all (cls, search_replace: dict[str, str], subject: str, encoding: str = 'UTF-8') -> str:
+        """
+        Заменяет в строке все вхождения строки поиска на строку замены.
+        :param search_replace: Словарь с парами поиска и замены. Например, {'-': '#', '$': '%'}
+                                заменит все дефисы на # и все доллары на %.
+        :param subject: Исходная строка.
+        :param encoding: Кодировка (по умолчанию, UTF-8).
+        :return: Результат замены.
+        """
+        # Создаю результат
+        result = subject
+        
+        # Для каждой пары поиска и замены
+        for search, replace in search_replace.items():
+            # - заменяю все вхождения строки поиска на строку замены в заданной строке
+            result = cls.replace(result, search, replace, encoding)
+        
+        # Возвращаю результат
+        return result

anb_python_components/extensions/string_extension_constant.py

@@ -0,0 +1,80 @@
+# anb_python_components/extensions/string_extension_constant.py
+
+
+class StringExtensionConstants:
+    """
+    Константы для расширения строк.
+
+    Attributes:
+        russian_letters (dict): Словарь соответствия русских букв в транслитерации.
+    """
+    
+    # Словарь соответствия русских букв в транслитерации
+    russian_letters = {
+            'а': 'a',
+            'б': 'b',
+            'в': 'v',
+            'г': 'g',
+            'д': 'd',
+            'е': 'e',
+            'ё': 'yo',
+            'ж': 'zh',
+            'з': 'z',
+            'и': 'i',
+            'й': 'j',
+            'к': 'k',
+            'л': 'l',
+            'м': 'm',
+            'н': 'n',
+            'о': 'o',
+            'п': 'p',
+            'р': 'r',
+            'с': 's',
+            'т': 't',
+            'у': 'u',
+            'ф': 'f',
+            'х': 'h',
+            'ц': 'c',
+            'ч': 'ch',
+            'ш': 'sh',
+            'щ': 'sch',
+            'ъ': 'j',
+            'ы': 'i',
+            'ь': 'j',
+            'э': 'e',
+            'ю': 'yu',
+            'я': 'ya',
+            'А': 'A',
+            'Б': 'B',
+            'В': 'V',
+            'Г': 'G',
+            'Д': 'D',
+            'Е': 'E',
+            'Ё': 'Yo',
+            'Ж': 'Zh',
+            'З': 'Z',
+            'И': 'I',
+            'Й': 'J',
+            'К': 'K',
+            'Л': 'L',
+            'М': 'M',
+            'Н': 'N',
+            'О': 'O',
+            'П': 'P',
+            'Р': 'R',
+            'С': 'S',
+            'Т': 'T',
+            'У': 'U',
+            'Ф': 'F',
+            'Х': 'H',
+            'Ц': 'C',
+            'Ч': 'Ch',
+            'Ш': 'Sh',
+            'Щ': 'Sch',
+            'Ъ': 'J',
+            'Ы': 'I',
+            'Ь': 'J',
+            'Э': 'E',
+            'Ю': 'Yu',
+            'Я': 'Ya'
+            }

anb_python_components/extensions/type_extension.py

@@ -0,0 +1,112 @@
+# anb_python_components/extensions/type_extension.py
+
+import datetime
+from typing import Any, List, Union, get_args, get_origin
+
+# Базовая структура для представления расширенного типа
+class TypeExtension:
+    """
+    Класс для расширения типов.
+    """
+    
+    def __init__ (self):
+        """
+        Инициализирует экземпляр класса.
+        """
+        pass
+    
+    @staticmethod
+    def to_dict (instance: Any) -> dict[str, Any]:
+        """
+        Преобразует экземпляр объекта в словарь.
+
+        :param instance: Экземпляр класса.
+        :return: Словарь представлений всех полей.
+        """
+        # Создаём словарь
+        result = {}
+        
+        # Перебираем поля экземпляра
+        for key, value in vars(instance).items():
+            # - если значение является экземпляром datetime, преобразуем его в timestamp
+            if isinstance(value, datetime.datetime):
+                result[key] = int(value.timestamp())
+                # - если значение является словарем, вызываем рекурсивно функцию to_dict
+            elif hasattr(value, '__dict__'):
+                result[key] = TypeExtension.to_dict(value)
+                # - иначе просто добавляем значение
+            else:
+                result[key] = value
+        
+        # Возвращаем словарь
+        return result
+    
+    @staticmethod
+    def from_dict (data: dict, cls = None) -> Any:
+        """
+        Восстанавливает объект из словаря.
+
+        :param data: Словарь, представляющий поля объекта.
+        :param cls: Класс для восстановления объекта (необязательный параметр, равный None по умолчанию).
+        :return: Восстановленный объект.
+        """
+        
+        # Проверяем, что класс указан и является типом
+        if cls is None or not isinstance(cls, type):
+            # - если класс не указан, бросаем исключение
+            raise TypeError('Класс для восстановления не указан.')
+        
+        # Создаём объект класса
+        # noinspection PyArgumentList
+        obj = cls.__new__(cls)
+        
+        # Перебираем поля словаря
+        for key, value in data.items():
+            # - если значение является словарем, вызываем рекурсивно функцию from_dict и устанавливаем результат в поле объекта
+            if isinstance(value, int) and hasattr(obj, key) and isinstance(getattr(obj, key), datetime.datetime):
+                setattr(obj, key, datetime.datetime.fromtimestamp(value))
+            elif isinstance(value, dict):
+                nested_cls = getattr(obj, key).__class__
+                setattr(obj, key, TypeExtension.from_dict(value, nested_cls))
+            else:
+                setattr(obj, key, value)
+        
+        # Возвращаем восстановленный объект
+        return obj
+    
+    @staticmethod
+    def is_immutable_type (t) -> bool:
+        """
+        Проверяет, является ли тип t примитивным/неизменяемым.
+        :param t: Тип.
+        :type t: type
+        :return: True, если тип является примитивным/неизменяемым, иначе False.
+        """
+        # Примитивные неизменяемые типы
+        immutable_types = (int, str, float, bool, type(None), tuple, frozenset)
+        
+        # Прямая проверка на примитивы
+        if t in immutable_types:
+            return True
+        
+        # Обработка Union
+        if get_origin(t) is Union:
+            args = get_args(t)
+            
+            # Если это Optional[T] (Union[T, None])
+            if len(args) == 2 and type(None) in args:
+                inner_type = args[0] if args[1] is type(None) else args[1]
+                return TypeExtension.is_immutable_type(inner_type)  # Рекурсивно проверяем T
+            
+            # Для обычного Union проверяем все аргументы
+            return all(TypeExtension.is_immutable_type(arg) for arg in args)
+        
+        # Обработка list[T], List[T]
+        if get_origin(t) in (list, List):
+            args = get_args(t)
+            if not args:  # list без параметра (list)
+                return False  # Считаем изменяемым
+            inner_type = args[0]  # Получаем T из list[T]
+            return TypeExtension.is_immutable_type(inner_type)  # Проверяем T
+        
+        return False

anb_python_components/models/__init__.py

@@ -0,0 +1 @@
+# anb_python_components/models/__init__.py

anb_python_components/models/action_state_message.py

@@ -0,0 +1,27 @@
+# anb_python_components/models/action_state_message.py
+from anb_python_components.enums.message_type import MessageType
+
+class ActionStateMessage:
+    """
+    Модель сообщения о состояния действия.
+    """
+    
+    def __init__ (
+            self, message_type: MessageType = MessageType.INFO, message: str = "", flags: dict[str, bool] | None = None
+            ):
+        """
+        Конструктор.
+        :param message_type: Тип сообщения (по умолчанию, INFO).
+        :param message: Текст сообщения (по умолчанию, пустая строка).
+        :param flags: Флаги сообщения (по умолчанию, пустой словарь).
+        """
+        self.message_type: MessageType = message_type
+        self.message: str = message
+        self.flags: dict[str, bool] = flags if flags is not None else []
+    
+    def __str__ (self):
+        """
+        Переопределение метода __str__.
+        :return: Текстовое представление модели.
+        """
+        return f"[{str(self.message_type).upper()}] {self.message}"

anb_python_components/models/shortcode_model.py

@@ -0,0 +1,31 @@
+from typing import Callable
+
+class ShortCodeModel:
+    """
+    Модель добавления шорткода.
+    """
+    
+    def __init__ (
+            self, short_code: str | None = None, on_set: Callable | None = None,
+            on_unset: Callable | None = None, on_validate: Callable | None = None
+            ):
+        """
+        Конструктор модели.
+
+        :param short_code: Буква, символ или последовательность символов, которая будет использоваться для шорткода.
+                           Если не указана, то будет использована пустая строка.
+        :type short_code: str | None
+        :param on_set: Обработчик действия шорткода при обработке текста, когда шорткод включен.
+                      Функция должна принимать два аргумента: content (str) и params (dict).
+        :type on_set: Callable | None
+        :param on_unset: Обработчик действия шорткода при обработке текста, когда шорткод отключен.
+                        Аналогично OnSet.
+        :type on_unset: Callable | None
+        :param on_validate: Обработчик действия шорткода при валидации самого шорткода.
+                           Функционал тот же, что и у OnSet и OnUnSet.
+        :type on_validate: Callable | None
+        """
+        self.shortcode: str = short_code or ''
+        self.on_set: Callable | None = on_set
+        self.on_unset: Callable | None = on_unset
+        self.on_validate: Callable | None = on_validate

anb_python_components-1.2.1.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: anb_python_components
+Version: 1.2.1
+Author: Александр Бабаев
+Author-email: contact_with_us@babaev-an.ru
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: license-file

anb_python_components-1.2.1.dist-info/RECORD

@@ -0,0 +1,48 @@
+anb_python_components/__init__.py,sha256=L4VwPTIFu2nTe0Wjhl5z7wzpWrlu27f1rn1ufITdpmw,35
+anb_python_components/classes/__init__.py,sha256=wzYF97ZvKcwJ71dXgaqO-RHeC6RiWxRzV_J3RM32TZQ,43
+anb_python_components/classes/action_state.py,sha256=1p-yjqrsjEJbBrKhTpjkK2EmYL00w41hNDxT4lQ6hjM,10369
+anb_python_components/classes/directory.py,sha256=s9Tw8ds6tg2haOH3qacK7TpASGjHU9E1rynb__e-Yjg,6696
+anb_python_components/classes/file.py,sha256=6loAIZBBCwiEQpSJ66rhxpwTzj8nkhC6yKW-UhmlUrw,12533
+anb_python_components/classes/shortcode_parser.py,sha256=4zQabHnqgvFtB9Yev7O8W7lkvJcLPQ-oMYP3F8GvVPY,9560
+anb_python_components/custom_types/__init__.py,sha256=5ko8rPsSg7P1E4iTxl116Dsxgu_Yzn7QOnnhAGv9FAo,81
+anb_python_components/custom_types/guid.py,sha256=Z43ZPjEmCx_A5b_hQWe6-j3fsra1QYdtKeNafQtxtPY,7815
+anb_python_components/custom_types/object_array.py,sha256=jFSDxyi2XiHR8s9EjIAO8yZnR6VwKLIaD-B-elbf4KE,30731
+anb_python_components/custom_types/shortcode_attributes.py,sha256=wRG1CR9AZ_GCzpz_yMf8DLdaonThPiYff4lKT44PeZg,5373
+anb_python_components/custom_types/two_dim_size.py,sha256=Bu7Kr8XIePRrKwoV5kJyyapPkKIHO6ZecWBsQ3bNUMM,21778
+anb_python_components/custom_types/version_info.py,sha256=_ONZ5nHb3vHyFj5Os7Ba36hE8uMXleI8D2u8UbaIA3E,20731
+anb_python_components/enums/__init__.py,sha256=MA5CU1-25qvZB8kTEPfF3k8vM5ZRZ0Bx_PtH6L_4r3Q,41
+anb_python_components/enums/message_type.py,sha256=knZPAOgIhwASJHDB7WYBf6c7fltUpVuoSwS3huKwKuY,1374
+anb_python_components/enums/not_bool_action.py,sha256=kY6CTzLe1Q38X3b4kB2ss2CgSElIJr7h70ZJI4PliqI,924
+anb_python_components/enums/type_copy_strategy.py,sha256=Sa-gtzTe5dyWKtjapoFQ3F1T26HxeCufOPL1TvKYJY4,1892
+anb_python_components/exceptions/__init__.py,sha256=42UYjSI-naSUIFcpDlbFrevY5RQdEeTmvmgabo32Cps,46
+anb_python_components/exceptions/wrong_type_exception.py,sha256=sT8t3C8TScfAq0Q9MP1AFdPk3r8mqlZ3yZhbBmdhYvc,1015
+anb_python_components/extensions/__init__.py,sha256=iG75Ml_0L-8G4aCB7_t-T6XpXllREbuTCpDAzNs4Yus,46
+anb_python_components/extensions/array_extension.py,sha256=KDWhxKHwmxBi7DMiDFzmZjPQdLv6J2HqlRP2cXSxJs8,1247
+anb_python_components/extensions/bool_extension.py,sha256=6E4h8XNIocrduG9vuHTOgrNVmSJEd4Qi-cYYfgTQbow,5097
+anb_python_components/extensions/string_extension.py,sha256=NbBVA7nEJ-N9LQK8IjM7WebW2fJcVP2cujwlsxGeVZQ,12391
+anb_python_components/extensions/string_extension_constant.py,sha256=BuQZZfPR9wuP8-izfMOri9ejRq96NA7CutmgQoEQPNM,2079
+anb_python_components/extensions/type_extension.py,sha256=M1hPJBs3OQyuxzYVM7z7GIUITQYJvE3ZEUoZS1cTnJ0,5279
+anb_python_components/models/__init__.py,sha256=wDBaXnroVv2B28gNWt3tMaxJZr6uwrzICPo6umKbT_w,42
+anb_python_components/models/action_state_message.py,sha256=TwoRVpMacBeVryQDT8E-3tSPeGPZMPKNQnDej3l8lWE,1205
+anb_python_components/models/shortcode_model.py,sha256=pmCcADRdtl797Hx49PIShDyp_ZdSTaEBWiqpfo9-Vh4,1836
+anb_python_components-1.2.1.dist-info/licenses/LICENSE,sha256=KcsvfUkDrcic4UUsLmT6KoMHIGxzumxUpyXz_AxbNUc,34196
+tests/__init__.py,sha256=OWz0Ua3ofMcvkBc9REOLWwUyCh7tL1XeAPZisU6wD2E,19
+tests/classes/__init__.py,sha256=8otxPyXe89vX4ajDH6Zj4V559aOEni2MIbsvfp2o_dg,27
+tests/classes/action_state_test.py,sha256=1t81Z8v7zGAWq4NamwoCFtJEP-hnzXMg2MTH7PrT87M,5154
+tests/classes/directory_test.py,sha256=BWeRaxdvSx8i0kFatx_vA2_CQE65z2omKykNnul-mDg,800
+tests/classes/file_test.py,sha256=C7CsK4AQzSeiN922uJsHRQeswKkqB9qKowmVa5cYcCU,2717
+tests/classes/shortcode_parser_test.py,sha256=tOjHYxyJIqvA4kZaD6KMwBHeDr7Bb3r9wrhs9lI8PZI,4662
+tests/custom_types/__init__.py,sha256=lT7EfzksF_WekNu3OYYMDkFgs5dcQQStVEkmc0bBGmU,32
+tests/custom_types/guid_test.py,sha256=MVwlZDJUeSuP0CMLFR14IesQ0r-jEhfkcrqwFlOQ9vY,378
+tests/custom_types/object_array_test.py,sha256=8KJDiKms6LLkitFgS24KGPWkqOB04GRN4K42y2gZXDU,4838
+tests/custom_types/two_dim_size_test.py,sha256=vbwveysgwo8zKCCjBt1HhNPd6ci5_ZiytzGoqVZWA5g,1035
+tests/custom_types/version_info_test.py,sha256=WlAA4csXQKbfsyHqW0nFM407-BVzTSNmAgFk_zoyNeM,2579
+tests/extensions/__init__.py,sha256=OoxNA3aYZ-MIfuuE4HnBPhV9g24WVP-_TVZOTmDAb5Q,30
+tests/extensions/array_extension_test.py,sha256=6HuGZTX8IjwFffZNfTDAinfncIoknJ3U0A6v3_H22sI,820
+tests/extensions/bool_extension_test.py,sha256=BNkWBJHpYldMAcrsZFwBsWLZtU8OTLNHpE2m4D_SD1k,674
+tests/extensions/string_extension_test.py,sha256=qB7LrqawFRR0skKnurlHuDgOhNjSiLVvFY047m5TohI,2968
+tests/extensions/type_extension_test.py,sha256=hB7Xwt-m8GgTfo-8nOPH8SQma6UzIwBMxzec1yvD1sc,1424
+anb_python_components-1.2.1.dist-info/METADATA,sha256=ktpvxSKGlKLFoubK8WvQ0y02eOUUml1rhY_71cjRQHc,364
+anb_python_components-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+anb_python_components-1.2.1.dist-info/top_level.txt,sha256=xZUQAZyFd9-k4FOsuIUIQfhk8rub887gWe9zmuBMvi0,28
+anb_python_components-1.2.1.dist-info/RECORD,,