absfuyu 2.8.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

absfuyu/{collections → general}/content.py

@@ -3,21 +3,18 @@ Absfuyu: Content
 ----------------
 Handle .txt file
 
-Version: 1.2.4
-Date updated: 24/11/2023 (dd/mm/yyyy)
+Version: 1.2.5
+Date updated: 27/11/2023 (dd/mm/yyyy)
 
 Usage:
 ------
->>> from absfuyu.collections.content import ContentLoader
+>>> from absfuyu.general.content import ContentLoader
 """
 
 
 # Module level
 ###########################################################################
-__all__ = [
-    "ContentLoader",
-    "Content", "LoadedContent"
-]
+__all__ = ["ContentLoader", "Content", "LoadedContent"]
 
 
 # Library
@@ -44,20 +41,23 @@ class Content:
     Data format: list[str, list[str]]
         where: ``str: data``; ``list[str]: data tags``
     """
+
     def __init__(self, data: list) -> None:
         self.data: str = str(data[0])
         self.tag: list = data[1]
         # logger.debug(self.__dict__)
+
     def __str__(self) -> str:
         # return f"{self.data} | {self.tag}"
         return str(self.data)
+
     def __repr__(self) -> str:
         return self.__str__()
 
-    def unidecoded(self):
+    def unidecoded(self) -> "Content":
         """
         Convert data through ``unidecode`` package
-        
+
         Returns
         -------
         Content
@@ -68,7 +68,7 @@ class Content:
     def to_text(self) -> str:
         """
         Convert back into text
-        
+
         Returns
         -------
         str
@@ -77,7 +77,7 @@ class Content:
         # hard code
         tags = ",".join(self.tag)
         return f"{self.data}|{tags}"
-    
+
     def short_form(self, separator: str = ",") -> str:
         """
         Short form show only first item when separated by ``separator``
@@ -86,7 +86,7 @@ class Content:
         ----------
         separator : str
             Default: ``","``
-        
+
         Returns
         -------
         str
@@ -95,20 +95,17 @@ class Content:
         if not separator.startswith(","):
             logger.debug(f"Separated symbol: {separator}")
         return self.data.split(separator)[0]
-    
+
     def handle_address(
-            self,
-            address_separator: str = ",",
-            *,
-            first_item_not_address: bool = True
-        ):
+        self, address_separator: str = ",", *, first_item_not_address: bool = True
+    ) -> "Content":
         """
         Handle ``self.data`` as address and then update the address into ``self.tag``
 
         Parameters
         ----------
         address_separator : str
-            | Split the address by which character 
+            | Split the address by which character
             | (Default: ``","``)
 
         first_item_not_address : bool
@@ -132,7 +129,9 @@ class Content:
         if first_item_not_address:
             temp = self.data.split(address_separator)
         else:
-            logger.debug(f"First item ({self.data.split(address_separator)[0]}) is not part of an address")
+            logger.debug(
+                f"First item ({self.data.split(address_separator)[0]}) is not part of an address"
+            )
             temp = self.data.split(address_separator)[1:]
 
         new_tag = [x.strip().lower() for x in temp]
@@ -143,20 +142,23 @@ class Content:
 
         return __class__([self.data, self.tag])
 
+
 class LoadedContent(List[Content]):
     """
     Contain list of ``Content``
     """
+
     def __str__(self) -> str:
         # return f"{self.__class__.__name__} - Total: {len(self)}"
         return f"{self.__class__.__name__}({[x.data for x in self]})"
+
     def __repr__(self) -> str:
         return self.__str__()
-    
-    def apply(self, func):
+
+    def apply(self, func) -> "LoadedContent":
         """
         Apply function to each entry
-        
+
         :param func: Callable function
         :type func: Callable
         :rtype: LoadedContent
@@ -164,7 +166,7 @@ class LoadedContent(List[Content]):
         return __class__(func(x.data) for x in self)
 
     @classmethod
-    def load_from_json(cls, file: Path):
+    def load_from_json(cls, file: Path) -> "LoadedContent":
         """
         Use this method to load data from ``.json`` file from ``to_json()`` method
 
@@ -172,7 +174,7 @@ class LoadedContent(List[Content]):
         ----------
         file : Path
             Path to ``.json`` file
-        
+
         Returns
         -------
         LoadedContent
@@ -190,21 +192,21 @@ class LoadedContent(List[Content]):
         out = list(set(temp))
         logger.debug(f"Found {len(out)} {'tags' if len(out) > 1 else 'tag'}")
         return sorted(out)
-    
+
     def tag_count(self) -> Counter:
         """
         Count number of tags
-        
+
         :rtype: Counter
         """
         temp = chain.from_iterable([x.tag for x in self])
         logger.debug(temp)
         return Counter(temp)
-    
-    def filter(self, tag: str):
+
+    def filter(self, tag: str) -> "LoadedContent":
         """
         Filter out entry with ``tag``
-        
+
         :param tag: Tag to filter
         :type tag: str
         :rtype: LoadedContent
@@ -214,18 +216,18 @@ class LoadedContent(List[Content]):
         if tag not in self.tags:
             # tag = random.choice(self.tags)
             # logger.debug(f"Tag not exist, changing to a random tag... {tag}")
-            logger.warning(f"\"{tag}\" tag does not exist")
+            logger.warning(f'"{tag}" tag does not exist')
             _avail_tag = ", ".join(list(dict(self.tag_count().most_common(5)).keys()))
             raise ValueError(
                 f"Available tags: {_avail_tag},..."
                 f"\nMore tag at: `{self.__class__.__name__}.tags`"
             )
         return __class__([x for x in self if tag in x.tag])
-    
-    def find(self, keyword: str):
+
+    def find(self, keyword: str) -> "LoadedContent":
         """
         Return all entries that include ``keyword``
-        
+
         :param keyword: Keyword to find
         :type keyword: str
         :rtype: LoadedContent
@@ -237,7 +239,7 @@ class LoadedContent(List[Content]):
             logger.debug("No result")
         return temp
 
-    def short_form(self, separator: str = ","):
+    def short_form(self, separator: str = ",") -> List[str]:
         """
         Shows only first item when separated by ``separator`` of ``Content.data``
 
@@ -245,7 +247,7 @@ class LoadedContent(List[Content]):
         ----------
         separator : str
             Default: ``","``
-        
+
         Returns
         -------
         list[str]
@@ -256,13 +258,13 @@ class LoadedContent(List[Content]):
     def pick_one(self, tag: Optional[str] = None) -> Content:
         """
         Pick a random entry
-        
+
         Parameters
         ----------
         tag : str | None
-            Pick a random entry with ``tag`` 
+            Pick a random entry with ``tag``
             (Default: None)
-        
+
         Returns
         -------
         Content
@@ -273,20 +275,17 @@ class LoadedContent(List[Content]):
             logger.debug(f"Tag: {tag}")
             return random.choice(temp)
         return random.choice(self)
-    
+
     def handle_address(
-            self,
-            address_separator: str = ",",
-            *,
-            first_item_not_address: bool = True
-        ):
+        self, address_separator: str = ",", *, first_item_not_address: bool = True
+    ) -> "LoadedContent":
         """
         Execute ``Content.handle_address()`` on every ``self.data`` of ``Content``
 
         Parameters
         ----------
         address_separator : str
-            | Split the address by which character 
+            | Split the address by which character
             | (Default: ``","``)
 
         first_item_not_address : bool
@@ -297,7 +296,7 @@ class LoadedContent(List[Content]):
         LoadedContent
             Handled Content
 
-  
+
         Example:
         --------
         >>> test = "Shop A, 22 ABC Street, DEF District, GHI City"
@@ -307,13 +306,16 @@ class LoadedContent(List[Content]):
         >>> # After handle_address(first_item_not_address = False)
         ["22 ABC Street", "DEF District", "GHI City"]
         """
-        return __class__([
-            x.handle_address(
-                address_separator=address_separator,
-                first_item_not_address=first_item_not_address
-            ) for x in self
-        ])
-    
+        return __class__(
+            [
+                x.handle_address(
+                    address_separator=address_separator,
+                    first_item_not_address=first_item_not_address,
+                )
+                for x in self
+            ]
+        )
+
     def to_json(self, no_accent: bool = False) -> str:
         """
         Convert data into ``.json`` file
@@ -323,7 +325,7 @@ class LoadedContent(List[Content]):
         no_accent : bool
             | when ``True``: convert the data through ``unidecode`` package
             | (Default: ``False``)
-        
+
         Returns
         -------
         str
@@ -345,7 +347,7 @@ class LoadedContent(List[Content]):
         no_accent : bool
             | when ``True``: convert the data through ``unidecode`` package
             | (Default: ``False``)
-        
+
         Returns
         -------
         str
@@ -358,6 +360,7 @@ class LoadedContent(List[Content]):
         logger.debug(out)
         return "\n".join(out)
 
+
 class ContentLoader:
     """
     This load data from ``.txt`` file
@@ -365,16 +368,17 @@ class ContentLoader:
     Content format:
     ``<content><split_symbol><tags separated by <tag_separate_symbol>>``
     """
+
     def __init__(
-            self,
-            file_path: Path,
-            characteristic_detect: bool = True,
-            tag_dictionary: dict = None,
-            *,
-            comment_symbol: str = "#",
-            split_symbol: str = "|",
-            tag_separate_symbol: str = ","
-        ) -> None:
+        self,
+        file_path: Path,
+        characteristic_detect: bool = True,
+        tag_dictionary: dict = None,
+        *,
+        comment_symbol: str = "#",
+        split_symbol: str = "|",
+        tag_separate_symbol: str = ",",
+    ) -> None:
         """
         Parameters
         ----------
@@ -389,7 +393,7 @@ class ContentLoader:
             custom tag pattern
             format: ``{"keyword": "tag",...}``
             example: ``{"apple": "fruit", "orange": "fruit"}``
-        
+
         comment_symbol : str
             symbol that `ContentLoader` will ignore
             (default: ``"#"``)
@@ -422,17 +426,22 @@ class ContentLoader:
             self.tag_dictionary: dict = tag_dictionary
 
         # symbol stuff
-        assert comment_symbol != split_symbol, "comment_symbol and split_symbol should have different values"
-        assert tag_separate_symbol != split_symbol, "tag_separate_symbol and split_symbol should have different values"
+        assert (
+            comment_symbol != split_symbol
+        ), "comment_symbol and split_symbol should have different values"
+        assert (
+            tag_separate_symbol != split_symbol
+        ), "tag_separate_symbol and split_symbol should have different values"
         self.comment_symbol: str = comment_symbol
         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
@@ -469,21 +478,25 @@ class ContentLoader:
             logger.debug("Loading data...")
             dat = []
             check = []
-            
+
             for i, x in enumerate(data.readlines()):
                 x = x.strip()
-                if x.startswith(self.comment_symbol) or len(x)==0:
-                    continue # skip comment and empty lines
-                logger.debug(f"### Loop {i+1} #####################################################################")
-                
+                if x.startswith(self.comment_symbol) or len(x) == 0:
+                    continue  # skip comment and empty lines
+                logger.debug(
+                    f"### Loop {i+1} #####################################################################"
+                )
+
                 temp = x.split(self.split_symbol)
                 if len(temp) != 2:
                     logger.debug(f"Split len: {len(temp)}")
-                    logger.warning(f"The current entry is missing data or tag: {x[:20]}...")
-                
+                    logger.warning(
+                        f"The current entry is missing data or tag: {x[:20]}..."
+                    )
+
                 temp[0] = temp[0].strip()
                 if temp[0].lower() not in check:
-                    check.append(temp[0].lower()) # check for dupes
+                    check.append(temp[0].lower())  # check for dupes
 
                     # tag
                     additional_tags = []
@@ -491,24 +504,29 @@ class ContentLoader:
                         key = k.strip().lower()
                         val = temp[0].lower()
                         regex_pattern = f"[^a-zA-Z0-9]({key})[^a-zA-Z0-9]|^({key})[^a-zA-Z0-9]|[^a-zA-Z0-9]({key})$"
-                        if re.search(regex_pattern, val) is not None or val.startswith(key):
+                        if re.search(regex_pattern, val) is not None or val.startswith(
+                            key
+                        ):
                             # regex has a bug (or idk if it's a bug or not) that
                             # doesn't recognise when there is only one word in the sentence
                             # therefore use `val.startswith(key)` to fix
                             additional_tags.append(v.strip().lower())
 
                     if self.characteristic_detect:
-                        long_short = (120, 20) # setting
+                        long_short = (120, 20)  # setting
                         if len(temp[0]) > long_short[0]:
                             additional_tags.append("long")
                         if len(temp[0]) < long_short[1]:
                             additional_tags.append("short")
                         if temp[0][-1].startswith("?"):
                             additional_tags.append("question")
-                    if additional_tags: logger.debug(f"Additional tags: {additional_tags}")
+                    if additional_tags:
+                        logger.debug(f"Additional tags: {additional_tags}")
 
                     try:
-                        tags = [tag.strip() for tag in temp[1].strip().lower().split(",")] # separate and strip tags
+                        tags = [
+                            tag.strip() for tag in temp[1].strip().lower().split(",")
+                        ]  # separate and strip tags
                         logger.debug(f"Tags: {tags}")
                     except:
                         logger.warning("No tag found in the original string")
@@ -516,18 +534,18 @@ class ContentLoader:
                             tags = additional_tags
                         else:
                             tags = ["unspecified"]
-                            logger.debug("Assigned \"unspecified\" tag")
-                    
+                            logger.debug('Assigned "unspecified" tag')
+
                     tags.extend(additional_tags)
                     final_tags = list(set(tags))
                     logger.debug(f"Final tags: {final_tags} Len: {len(final_tags)}")
 
-                    dat.append([temp[0], final_tags]) # add everything
+                    dat.append([temp[0], final_tags])  # add everything
                 else:
                     logger.debug(f"Found duplicates, {x} removed")
 
         return dat
-    
+
     def load_content(self) -> LoadedContent:
         """
         Load data into a list of ``Content``
@@ -543,4 +561,4 @@ class ContentLoader:
 # Run
 ###########################################################################
 if __name__ == "__main__":
-    logger.setLevel(10)
+    logger.setLevel(10)