absfuyu 4.2.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

absfuyu/general/content.py

@@ -11,29 +11,30 @@ Usage:
 >>> from absfuyu.general.content import ContentLoader
 """
 
+# TODO: rewrite this
+
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = ["ContentLoader", "Content", "LoadedContent"]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import json
 import random
 import re
 from collections import Counter
 from itertools import chain
 from pathlib import Path
-from typing import List, Optional
-
-from unidecode import unidecode
+from typing import Self
 
+from absfuyu.core import BaseClass, ShowAllMethodsMixin, unidecode
 from absfuyu.logger import logger
 
 
 # Class
-###########################################################################
-class Content:
+# ---------------------------------------------------------------------------
+class Content(BaseClass):
     """
     Contain data
 
@@ -50,10 +51,7 @@ class Content:
         # return f"{self.data} | {self.tag}"
         return str(self.data)
 
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    def unidecoded(self) -> "Content":
+    def unidecoded(self) -> Self:
         """
         Convert data through ``unidecode`` package
 
@@ -97,7 +95,7 @@ class Content:
 
     def handle_address(
         self, address_separator: str = ",", *, first_item_not_address: bool = True
-    ) -> "Content":
+    ) -> Self:
         """
         Handle ``self.data`` as address and then update the address into ``self.tag``
 
@@ -142,7 +140,7 @@ class Content:
         return self.__class__([self.data, self.tag])
 
 
-class LoadedContent(List[Content]):
+class LoadedContent(list[Content], ShowAllMethodsMixin):
     """
     Contain list of ``Content``
     """
@@ -154,7 +152,7 @@ class LoadedContent(List[Content]):
     def __repr__(self) -> str:
         return self.__str__()
 
-    def apply(self, func) -> "LoadedContent":
+    def apply(self, func) -> Self:
         """
         Apply function to each entry
 
@@ -165,7 +163,7 @@ class LoadedContent(List[Content]):
         return self.__class__(func(x.data) for x in self)
 
     @classmethod
-    def load_from_json(cls, file: Path) -> "LoadedContent":
+    def load_from_json(cls, file: Path) -> Self:
         """
         Use this method to load data from ``.json`` file from ``to_json()`` method
 
@@ -202,7 +200,7 @@ class LoadedContent(List[Content]):
         logger.debug(temp)
         return Counter(temp)
 
-    def filter(self, tag: str) -> "LoadedContent":
+    def filter(self, tag: str) -> Self:
         """
         Filter out entry with ``tag``
 
@@ -223,7 +221,7 @@ class LoadedContent(List[Content]):
             )
         return self.__class__([x for x in self if tag in x.tag])
 
-    def find(self, keyword: str) -> "LoadedContent":
+    def find(self, keyword: str) -> Self:
         """
         Return all entries that include ``keyword``
 
@@ -240,7 +238,7 @@ class LoadedContent(List[Content]):
             logger.debug("No result")
         return temp
 
-    def short_form(self, separator: str = ",") -> List[str]:
+    def short_form(self, separator: str = ",") -> list[str]:
         """
         Shows only first item when separated by ``separator`` of ``Content.data``
 
@@ -256,7 +254,7 @@ class LoadedContent(List[Content]):
         """
         return [x.short_form(separator) for x in self]
 
-    def pick_one(self, tag: Optional[str] = None) -> Content:
+    def pick_one(self, tag: str | None = None) -> Content:
         """
         Pick a random entry
 
@@ -279,7 +277,7 @@ class LoadedContent(List[Content]):
 
     def handle_address(
         self, address_separator: str = ",", *, first_item_not_address: bool = True
-    ) -> "LoadedContent":
+    ) -> Self:
         """
         Execute ``Content.handle_address()`` on every ``self.data`` of ``Content``
 
@@ -362,7 +360,7 @@ class LoadedContent(List[Content]):
         return "\n".join(out)
 
 
-class ContentLoader:
+class ContentLoader(BaseClass):
     """
     This load data from ``.txt`` file
 
@@ -372,9 +370,9 @@ class ContentLoader:
 
     def __init__(
         self,
-        file_path: Path,
+        file_path: Path | str,
         characteristic_detect: bool = True,
-        tag_dictionary: Optional[dict] = None,
+        tag_dictionary: dict | None = None,
         *,
         comment_symbol: str = "#",
         split_symbol: str = "|",
@@ -437,12 +435,6 @@ class ContentLoader:
         self.split_symbol: str = split_symbol
         self.tag_separate_symbol: str = tag_separate_symbol
 
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}({self.__dict__})"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
     def content_format(self) -> str:
         """
         Shows current content format
@@ -462,7 +454,7 @@ class ContentLoader:
         out = (
             f"{self.comment_symbol} This line will be ignored\n"
             f"<content> {self.split_symbol} "
-            f"<tag1>{self.tag_separate_symbol} <tag2>"
+            f"<tag1>{self.tag_separate_symbol} <tag2>, ..., <tag n>"
         )
         return out
 
@@ -557,9 +549,3 @@ class ContentLoader:
             Loaded content
         """
         return LoadedContent(map(Content, self.load()))
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)

absfuyu/general/generator.py

@@ -3,8 +3,8 @@ Absfuyu: Generator
 ------------------
 This generate stuff (Not python's ``generator``)
 
-Version: 1.1.1
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 25/02/2025 (dd/mm/yyyy)
 
 Features:
 ---------
@@ -15,32 +15,23 @@ Features:
 """
 
 # Module level
-###########################################################################
+# ---------------------------------------------------------------------------
 __all__ = ["Charset", "Generator"]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import string
 from itertools import chain, combinations
 from random import choice
 
-# from string import (
-#     ascii_letters as _ascii_letters,
-#     ascii_uppercase as _ascii_uppercase,
-#     ascii_lowercase as _ascii_lowercase,
-#     digits as _digits,
-#     printable as _printable,
-#     punctuation as _punctuation,
-# )
-from typing import List
-
+from absfuyu.core import BaseClass
 from absfuyu.logger import logger
 from absfuyu.util import set_max, set_min_max
 
 
 # Class
-###########################################################################
+# ---------------------------------------------------------------------------
 class Charset:
     """
     Character set data class
@@ -55,14 +46,6 @@ class Charset:
     SPECIAL = string.punctuation
     ALL = string.printable
     PRODUCT_KEY = "BCDFGHJKMNPQRTVWXY2346789"  # Charset that various key makers use
-    # DEFAULT = _ascii_letters + _digits
-    # ALPHABET = _ascii_letters
-    # FULL = _ascii_letters + _digits + _punctuation
-    # UPPERCASE = _ascii_uppercase
-    # LOWERCASE = _ascii_lowercase
-    # DIGIT = _digits
-    # SPECIAL = _punctuation
-    # ALL = _printable
 
     def __str__(self) -> str:
         charset = [x for x in self.__class__.__dict__.keys() if not x.startswith("__")]
@@ -72,20 +55,11 @@ class Charset:
         return self.__str__()
 
 
-class Generator:
+class Generator(BaseClass):
     """
     Generator that generate stuffs
     """
 
-    def __init__(self) -> None:
-        logger.debug("Class initiated!")
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}()"
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
     @staticmethod
     def generate_string(
         charset: str = Charset.DEFAULT,
@@ -173,8 +147,9 @@ class Generator:
         else:
             return unique_string
 
-    @staticmethod
+    @classmethod
     def generate_key(
+        cls,
         charset: str = Charset.PRODUCT_KEY,
         letter_per_block: int = 5,
         number_of_block: int = 5,
@@ -213,7 +188,7 @@ class Generator:
         'VKKPJVYD2H-M7R687QCV2'
         """
         out = sep.join(
-            __class__.generate_string(  # type: ignore
+            cls.generate_string(
                 charset,
                 size=letter_per_block,
                 times=number_of_block,
@@ -285,7 +260,7 @@ class Generator:
     @staticmethod
     def combinations_range(
         sequence: list, *, min_len: int = 1, max_len: int = 0
-    ) -> List[tuple]:
+    ) -> list[tuple]:
         """
         Generate all combinations of a ``sequence`` from ``min_len`` to ``max_len``
 
@@ -306,6 +281,12 @@ class Generator:
         -------
         list[tuple]
             A list of all combinations from range(``min_len``, ``max_len``) of ``sequence``
+
+
+        Example:
+        --------
+        >>> Generator.combinations_range([1, 2, 3], min_len=2)
+        [(1, 2), (1, 3), (2, 3), (1, 2, 3)]
         """
         # Restrain
         if max_len < 1:
@@ -320,9 +301,3 @@ class Generator:
                 [list(combinations(sequence, i)) for i in range(min_len, max_len + 1)]
             )
         )
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)  # DEBUG