absfuyu 4.0.0__tar.gz → 4.1.0__tar.gz

{absfuyu-4.0.0 → absfuyu-4.1.0}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022-2024 AbsoluteWinter
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2022-2025 AbsoluteWinter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{absfuyu-4.0.0 → absfuyu-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: absfuyu
-Version: 4.0.0
+Version: 4.1.0
 Summary: A small collection of code
 Project-URL: Homepage, https://github.com/AbsoluteWinter/absfuyu-public
 Project-URL: Documentation, https://absolutewinter.github.io/absfuyu-docs/
@@ -46,6 +46,7 @@ Requires-Dist: absfuyu-res; extra == 'full'
 Requires-Dist: numpy; extra == 'full'
 Requires-Dist: pandas; extra == 'full'
 Requires-Dist: rich; extra == 'full'
+Requires-Dist: tqdm; extra == 'full'
 Provides-Extra: res
 Requires-Dist: absfuyu-res; extra == 'res'
 Description-Content-Type: text/markdown

{absfuyu-4.0.0 → absfuyu-4.1.0}/pyproject.toml

@@ -5,7 +5,7 @@
 # 4. Build package (hatch build)
 # 5. Generating docs (hatch run docs:build)
 # 6. Publish packge (hatch publish)
-## Run entire workflow: hatch run workflow:perform
+## Run entire workflow: hatch run workflow:<major | minor | patch>
 ## `hatch env show` for more information
 
 # MARK: BUILD ====================
@@ -60,7 +60,7 @@ Issues = "https://github.com/AbsoluteWinter/absfuyu-public/issues"
 
 [project.optional-dependencies]
 res = ["absfuyu-res"]
-full = ["absfuyu-res", "numpy", "pandas", "rich"]
+full = ["absfuyu-res", "numpy", "pandas", "rich", "tqdm"]
 beautiful = ["rich"]
 extra = ["numpy", "pandas"]
 dev = ["hatch", "pytest"]
@@ -171,12 +171,12 @@ detached = true
 skip-install = true
 description = """
 Package workflow:
-hatch run workflow:perform
+hatch run workflow:<option>
 
-Note:
-- perform: bump version patch
-- perform2: bump version minor
-- perform3: bump version major
+Options:
+- patch: release version patch
+- minor: release version minor
+- major: release version major
 """
 
 [tool.hatch.envs.workflow.scripts]
@@ -186,25 +186,54 @@ test = [
     "hatch run all:test",    # Test
 ]
 build = [
+    # Update license year - Convert to hex due to unable to run multiple lines
+    # Source code:
+    # import re;from datetime import datetime;from pathlib import Path
+    # print("Updating license year...");p=r"([12]\d{3})(-[12]\d{3})?"
+    # n=str(datetime.now().year);l=list(Path.cwd().glob("*license*"))[0]
+    # with open(l)as f:c=f.readlines()
+    # for i,x in enumerate(c):
+    #     s=re.search(p,x);y=s.groups()[0]if s else n
+    #     if y!=n:c[i]=re.sub(p,f"{y}-{n}",x)
+    # with open(l,"w",encoding="utf-8")as f:f.writelines(c)
+    # print("License year updated")
+    """
+    python -c \"exec(bytes.fromhex('696d706f72742072653b66726f6d20646174657\
+    4696d6520696d706f7274206461746574696d653b66726f6d20706174686c696220696d\
+    706f727420506174680a7072696e7428225570646174696e67206c6963656e736520796\
+    561722e2e2e22293b703d7222285b31325d5c647b337d29282d5b31325d5c647b337d29\
+    3f220a6e3d737472286461746574696d652e6e6f7728292e79656172293b6c3d6c69737\
+    428506174682e63776428292e676c6f6228222a6c6963656e73652a2229295b305d0a77\
+    697468206f70656e286c29617320663a633d662e726561646c696e657328290a666f722\
+    0692c7820696e20656e756d65726174652863293a0a20202020733d72652e7365617263\
+    6828702c78293b793d732e67726f75707328295b305d6966207320656c7365206e0a202\
+    0202069662079213d6e3a635b695d3d72652e73756228702c66227b797d2d7b6e7d222c\
+    78290a77697468206f70656e286c2c2277222c656e636f64696e673d227574662d38222\
+    9617320663a662e77726974656c696e65732863290a7072696e7428224c6963656e7365\
+    207965617220757064617465642229').decode('utf-8'))\"
+    """,
+    # "python support_scripts/update_license_year.py", # Update license year
     "hatch clean",          # Clean dist/ folder
     "hatch -v build",       # Build package
     "hatch run docs:build", # Build docs
-    "hatch publish",        # Publish
 ]
-perform = [
+patch = [
     "test",
     "hatch version patch", # Bump version patch
     "build",
+    "hatch publish",       # Publish
 ]
-perform2 = [
+minor = [
     "test",
     "hatch version minor", # Bump version minor
     "build",
+    "hatch publish",       # Publish
 ]
-perform3 = [
+major = [
     "test",
     "hatch version major", # Bump version major
     "build",
+    "hatch publish",       # Publish
 ]
 
 # MARK: TOOL: pytest
@@ -223,7 +252,7 @@ markers = [ # pytest -m <marker> -v
 
 # MARK: TOOL: mypy
 [tool.mypy]
-# python_version = "3.8"
+python_version = "3.11"
 mypy_path = "src"
 check_untyped_defs = true
 # disallow_any_generics = true
@@ -279,6 +308,7 @@ ignore = [
 "tests/*" = [
     "F401", # imported but unused
 ]
+"shorten_number.py" = ["B007"] # Loop control variable not used within loop body
 
 # MARK: TOOL: black
 [tool.black]

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/__init__.py

@@ -22,7 +22,7 @@ Using in cmd (`absfuyu[cli]` required):
 __title__ = "absfuyu"
 __author__ = "AbsoluteWinter"
 __license__ = "MIT License"
-__version__ = "4.0.0"
+__version__ = "4.1.0"
 __all__ = [
     "core",
     "config",

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/cli/do_group.py

@@ -3,13 +3,14 @@ ABSFUYU CLI
 -----------
 Do
 
-Version: 1.2.0
-Date updated: 07/01/2025 (dd/mm/yyyy)
+Version: 1.3.0
+Date updated: 01/02/2025 (dd/mm/yyyy)
 """
 
 __all__ = ["do_group"]
 
 import subprocess
+from typing import Literal
 
 import click
 
@@ -17,6 +18,7 @@ from absfuyu import __title__
 from absfuyu.cli.color import COLOR
 from absfuyu.core import __package_feature__
 from absfuyu.general.human import Human2
+from absfuyu.tools.checksum import checksum_operation
 from absfuyu.util.zipped import Zipper
 from absfuyu.version import PkgVersion
 
@@ -96,6 +98,40 @@ def unzip_files_in_dir(dir: str) -> None:
     print("Done")
 
 
+@click.command(name="checksum")
+@click.argument("file_path", type=str)
+@click.option(
+    "--hashmode",
+    "-m",
+    "hash_mode",
+    type=click.Choice(["md5", "sha1", "sha256", "sha512"]),
+    default="sha256",
+    show_default=True,
+    help="Hash mode",
+)
+@click.option(
+    "--compare",
+    "-c",
+    "hash_to_compare",
+    type=str,
+    default=None,
+    show_default=True,
+    help="Hash to compare",
+)
+def file_checksum(
+    file_path: str,
+    hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"],
+    hash_to_compare: str,
+) -> None:
+    """Checksum for file"""
+
+    res = checksum_operation(file_path, hash_mode=hash_mode)
+    if hash_to_compare:
+        print(res == hash_to_compare)
+    else:
+        print(res)
+
+
 @click.group(name="do")
 def do_group() -> None:
     """Perform functionalities"""
@@ -108,3 +144,4 @@ do_group.add_command(advice)
 do_group.add_command(fs)
 do_group.add_command(info)
 do_group.add_command(unzip_files_in_dir)
+do_group.add_command(file_checksum)

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/core.py

@@ -3,8 +3,8 @@ Absfuyu: Core
 -------------
 Contain type hints and other stuffs
 
-Version: 2.2.1
-Date updated: 14/11/2024 (dd/mm/yyyy)
+Version: 2.3.0
+Date updated: 01/02/2025 (dd/mm/yyyy)
 """
 
 # Module Package
@@ -21,7 +21,11 @@ __all__ = [
 __package_feature__ = ["beautiful", "extra", "res", "full", "dev"]
 
 
+# Library
+###########################################################################
+from importlib import import_module
 from importlib.resources import files
+from typing import Iterable
 
 
 class CLITextColor:
@@ -43,3 +47,12 @@ class CLITextColor:
 CORE_PATH = files("absfuyu")
 CONFIG_PATH = CORE_PATH.joinpath("config", "config.json")
 DATA_PATH = CORE_PATH.joinpath("pkg_data")
+
+
+# tqdm wrapper
+try:
+    tqdm = import_module("tqdm").tqdm
+except ModuleNotFoundError:
+
+    def tqdm(iterable: Iterable, **kwargs):
+        return iterable

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/game/__init__.py

@@ -82,7 +82,7 @@ def game_escapeLoop() -> None:
                 print(x)
             stop_time = time.time()
             break
-    print(f"= Escaped in {stop_time-start_time:,.2f}s =")
+    print(f"= Escaped in {stop_time - start_time:,.2f}s =")
 
 
 # Rock Paper Scissors

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/game/game_stat.py

@@ -26,7 +26,7 @@ class GameStats:
     def _update_win_rate(self) -> None:
         try:
             self._win_rate = self.win / (self.win + self.draw + self.lose)
-            self.win_rate = f"{self._win_rate*100:,.2f}%"
+            self.win_rate = f"{self._win_rate * 100:,.2f}%"
         except ZeroDivisionError:
             self._win_rate = 0
             self.win_rate = "N/A"

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/general/content.py

@@ -427,12 +427,12 @@ class ContentLoader:
             self.tag_dictionary = 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
@@ -485,7 +485,7 @@ class ContentLoader:
                 if x.startswith(self.comment_symbol) or len(x) == 0:
                     continue  # skip comment and empty lines
                 logger.debug(
-                    f"### Loop {i+1} #####################################################################"
+                    f"### Loop {i + 1} #####################################################################"
                 )
 
                 temp = x.split(self.split_symbol)

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/general/data_extension.py

@@ -302,7 +302,7 @@ class Text(str):
                 output.append(f"{splt_name[i]}='{temp[i]}'")
         else:
             for i in range(splt_len):
-                output.append(f"{custom_var_name}{i+1}='{temp[i]}'")
+                output.append(f"{custom_var_name}{i + 1}='{temp[i]}'")
 
         # joined variable
         temp = []
@@ -319,9 +319,9 @@ class Text(str):
                 if i == 0:
                     temp.append(f"{custom_var_name}=")
                 if i == splt_len - 1:
-                    temp.append(f"{custom_var_name}{i+1}")
+                    temp.append(f"{custom_var_name}{i + 1}")
                 else:
-                    temp.append(f"{custom_var_name}{i+1}+")
+                    temp.append(f"{custom_var_name}{i + 1}+")
 
         output.append("".join(temp))
         if custom_var_name is None:

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/general/generator.py

@@ -156,7 +156,9 @@ class Generator:
 
         while count < times:
             s = "".join(choice(char_lst) for _ in range(size))
-            logger.debug(f"Time generated: {count+1}. Remaining: {times-count-1}. {s}")
+            logger.debug(
+                f"Time generated: {count + 1}. Remaining: {times - count - 1}. {s}"
+            )
             if not unique:
                 unique_string.append(s)
                 count += 1
@@ -274,7 +276,7 @@ class Generator:
                 if num[i] >= 10:  # type: ignore
                     num[i] -= 9  # type: ignore
             sum += num[i]  # type: ignore
-            logger.debug(f"Loop {i+1}: {num[i]}, {sum}")
+            logger.debug(f"Loop {i + 1}: {num[i]}, {sum}")
 
         out = (10 - (sum % 10)) % 10
         logger.debug(f"Output: {out}")

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/logger.py

@@ -100,7 +100,7 @@ def _compress_list_for_print(iterable: list, max_visible: Optional[int] = 5) ->
         # temp = [iterable[:cut_idx_1], ["..."], iterable[len(iterable)-cut_idx_2:]]
         # out = list(chain.from_iterable(temp))
         # out = [*iterable[:cut_idx_1], "...", *iterable[len(iterable)-cut_idx_2:]] # Version 2
-        out = f"{str(iterable[:cut_idx_1])[:-1]}, ...,{str(iterable[len(iterable)-cut_idx_2:])[1:]}"  # Version 3
+        out = f"{str(iterable[:cut_idx_1])[:-1]}, ...,{str(iterable[len(iterable) - cut_idx_2 :])[1:]}"  # Version 3
         # logger.debug(out)
         return f"{out} [Len: {len(iterable)}]"
 
@@ -123,7 +123,7 @@ def _compress_string_for_print(text: str, max_visible: Optional[int] = 120) -> s
         return str(text)
     else:
         cut_idx = math.floor((max_visible - 3) / 2)
-        temp = f"{text[:cut_idx]}...{text[len(text)-cut_idx:]}"
+        temp = f"{text[:cut_idx]}...{text[len(text) - cut_idx :]}"
         return f"{temp} [Len: {len(text)}]"
 
 

absfuyu-4.1.0/src/absfuyu/tools/checksum.py

@@ -0,0 +1,56 @@
+"""
+Absufyu: Checksum
+-----------------
+Check MD5, SHA256, ...
+
+Version: 1.0.0
+Date updated: 01/02/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+###########################################################################
+__all__ = ["checksum_operation"]
+
+
+# Library
+###########################################################################
+import hashlib
+from pathlib import Path
+from typing import Literal
+
+
+# Function
+###########################################################################
+def checksum_operation(
+    file: Path | str,
+    hash_mode: str | Literal["md5", "sha1", "sha256", "sha512"] = "sha256",
+) -> str:
+    """This performs checksum"""
+    if hash_mode.lower() == "md5":
+        hash_engine = hashlib.md5()
+    elif hash_mode.lower() == "sha1":
+        hash_engine = hashlib.sha1()
+    elif hash_mode.lower() == "sha256":
+        hash_engine = hashlib.sha256()
+    elif hash_mode.lower() == "sha512":
+        hash_engine = hashlib.sha512()
+    else:
+        hash_engine = hashlib.md5()
+
+    with open(Path(file), "rb") as f:
+        # Read and hash the file in 4K chunks. Reading the whole
+        # file at once might consume a lot of memory if it is
+        # large.
+        while True:
+            data = f.read(4096)
+            if len(data) == 0:
+                break
+            else:
+                hash_engine.update(data)
+    return hash_engine.hexdigest()
+
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    pass

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/tools/converter.py

@@ -3,8 +3,8 @@ Absufyu: Converter
 ------------------
 Convert stuff
 
-Version: 1.2.3
-Date updated: 25/11/2024 (dd/mm/yyyy)
+Version: 1.3.0
+Date updated: 01/02/2025 (dd/mm/yyyy)
 
 Feature:
 --------
@@ -25,6 +25,7 @@ import math
 import re
 import string
 from itertools import chain, combinations
+from pathlib import Path
 
 from absfuyu.core import CLITextColor
 from absfuyu.logger import logger
@@ -48,6 +49,29 @@ class Base64EncodeDecode:
     def decode(data: str) -> str:
         return base64.b64decode(data).decode()
 
+    @staticmethod
+    def encode_image(img_path: Path | str, data_tag: bool = False) -> str:
+        """Encode image file into base64 string
+
+        Parameters
+        ----------
+        img_path : Path | str
+            Path to image
+        data_tag : bool, optional
+            Add data tag before base64 string, by default False
+
+        Returns
+        -------
+        str
+            Encoded image
+        """
+        img = Path(img_path)
+        with open(img, "rb") as img_file:
+            b64_data = base64.b64encode(img_file.read()).decode("utf-8")
+        if data_tag:
+            return f"data:image/{img.suffix[1:]};charset=utf-8;base64,{b64_data}"
+        return b64_data
+
 
 class ChemistryElement:
     """Chemistry Element"""

{absfuyu-4.0.0 → absfuyu-4.1.0}/src/absfuyu/tools/obfuscator.py

@@ -217,7 +217,7 @@ class Obfuscator:
             )
             for x in bait_lst:
                 output.append(
-                    f"{x}='{gen.generate_string(charset=Charset.DEFAULT,size=self.split_every_length,times=1,string_type_if_1=True)}'"
+                    f"{x}='{gen.generate_string(charset=Charset.DEFAULT, size=self.split_every_length, times=1, string_type_if_1=True)}'"
                 )
 
             random_eval_text = str(random.randint(1, 100))

absfuyu-4.1.0/src/absfuyu/util/shorten_number.py

@@ -0,0 +1,228 @@
+"""
+Absfuyu: Shorten number
+---------------
+Short number base on suffixes
+
+Version: 1.0.0
+Last update: 01/02/2025 (dd/mm/yyyy)
+"""
+
+# Module level
+###########################################################################
+__all__ = ["UnitSuffixFactory", "CommonUnitSuffixesFactory", "Decimal"]
+
+
+# Library
+###########################################################################
+from dataclasses import dataclass, field
+from typing import Annotated, NamedTuple, Self
+
+
+# Class
+###########################################################################
+class UnitSuffixFactory(NamedTuple):
+    base: int
+    short_name: list[str]
+    full_name: list[str]
+
+
+class CommonUnitSuffixesFactory:
+    NUMBER = UnitSuffixFactory(
+        1000,
+        [
+            "",
+            "K",
+            "M",
+            "B",
+            "T",
+            "Qa",
+            "Qi",
+            "Sx",
+            "Sp",
+            "Oc",
+            "No",
+            "Dc",
+            "Ud",
+            "Dd",
+            "Td",
+            "Qad",
+            "Qid",
+            "Sxd",
+            "Spd",
+            "Ocd",
+            "Nod",
+            "Vg",
+            "Uvg",
+            "Dvg",
+            "Tvg",
+            "Qavg",
+            "Qivg",
+            "Sxvg",
+            "Spvg",
+            "Ovg",
+            "Nvg",
+            "Tg",
+            "Utg",
+            "Dtg",
+            "Ttg",
+            "Qatg",
+            "Qitg",
+            "Sxtg",
+            "Sptg",
+            "Otg",
+            "Ntg",
+        ],
+        [
+            "",  # < Thousand
+            "Thousand",
+            "Million",
+            "Billion",  # 1e9
+            "Trillion",
+            "Quadrillion",
+            "Quintillion",
+            "Sextillion",
+            "Septillion",
+            "Octillion",
+            "Nonillion",
+            "Decillion",  # 1e33
+            "Undecillion",
+            "Duodecillion",
+            "Tredecillion",
+            "Quattuordecillion",
+            "Quindecillion",
+            "Sexdecillion",
+            "Septendecillion",
+            "Octodecillion",
+            "Novemdecillion",
+            "Vigintillion",  #  1e63
+            "Unvigintillion",
+            "Duovigintillion",
+            "Tresvigintillion",
+            "Quattuorvigintillion",
+            "Quinvigintillion",
+            "Sesvigintillion",
+            "Septemvigintillion",
+            "Octovigintillion",
+            "Novemvigintillion",
+            "Trigintillion",  # 1e93
+            "Untrigintillion",
+            "Duotrigintillion",
+            "Trestrigintillion",
+            "Quattuortrigintillion",
+            "Quintrigintillion",
+            "Sestrigintillion",
+            "Septentrigintillion",
+            "Octotrigintillion",
+            "Noventrigintillion",  #  1e120
+        ],
+    )
+    DATA_SIZE = UnitSuffixFactory(
+        1024,
+        ["b", "Kb", "MB", "GB", "TB", "PB", "EB", "ZB", "YB", "BB"],
+        [
+            "byte",
+            "kilobyte",
+            "megabyte",
+            "gigabyte",
+            "terabyte",
+            "petabyte",
+            "exabyte",
+            "zetabyte",
+            "yottabyte",
+            "brontobyte",
+        ],
+    )
+
+
+@dataclass
+class Decimal:
+    """
+    Shorten large number
+
+    :param original_value: Value to shorten
+    :param base: Short by base (must be > 0)
+    :param suffixes: List of suffixes to use (ascending order)
+    :param factory: ``UnitSuffixFactory`` to use (will overwrite ``base`` and ``suffixes``)
+    :param suffix_full_name: Use suffix full name (default: False)
+    """
+
+    original_value: int | float = field(repr=False)
+    base: Annotated[int, "positive", "not_zero"] = field(repr=False, default=1000)
+    suffixes: list[str] = field(repr=False, default_factory=list)
+    factory: UnitSuffixFactory | None = field(repr=False, default=None)
+    suffix_full_name: bool = field(repr=False, default=False)
+    # Post init
+    value: int | float = field(init=False)
+    suffix: str = field(init=False)
+
+    def __post_init__(self) -> None:
+        self._get_factory()
+        self.value, self.suffix = self._convert_decimal()
+
+    def __str__(self) -> str:
+        return self.to_text()
+
+    @classmethod
+    def number(cls, value: int | float, suffix_full_name: bool = False) -> Self:
+        """Decimal for normal large number"""
+        return cls(
+            value,
+            factory=CommonUnitSuffixesFactory.NUMBER,
+            suffix_full_name=suffix_full_name,
+        )
+
+    @classmethod
+    def data_size(cls, value: int | float, suffix_full_name: bool = False) -> Self:
+        """Decimal for data size"""
+        return cls(
+            value,
+            factory=CommonUnitSuffixesFactory.DATA_SIZE,
+            suffix_full_name=suffix_full_name,
+        )
+
+    @staticmethod
+    def scientific_short(value: int | float) -> str:
+        """Short number in scientific format"""
+        return f"{value:.2e}"
+
+    def _get_factory(self) -> None:
+        if self.factory:
+            self.base = self.factory.base
+            self.suffixes = (
+                self.factory.full_name
+                if self.suffix_full_name
+                else self.factory.short_name
+            )
+
+    def _convert_decimal(self) -> tuple[float, str]:
+        """Convert to smaller number"""
+        suffix = self.suffixes[0] if len(self.suffixes) > 0 else ""
+        unit = 1
+        for i, suffix in enumerate(self.suffixes):
+            unit = self.base**i
+            if self.original_value < unit * self.base:
+                break
+        output = self.original_value / unit
+        return output, suffix
+
+    def to_text(
+        self, decimal: int = 2, *, separator: str = " ", float_only: bool = True
+    ) -> str:
+        """
+        Convert to string
+
+        :param decimal: Round up to which decimal
+        :param separator: Character between value and suffix, default: ``" "``
+        :param float_only: Returns value as <float> instead of <int> when ``decimal = 0``
+        """
+        val = self.value.__round__(decimal)
+        formatted_value = f"{val:,}"
+        if not float_only and decimal == 0:
+            formatted_value = f"{int(val):,}"
+        return f"{formatted_value}{separator}{self.suffix}"
+
+
+# Run
+###########################################################################
+if __name__ == "__main__":
+    print(str(Decimal.number(10000)))

{absfuyu-4.0.0 → absfuyu-4.1.0}/tests/test_everything.py

@@ -1,8 +1,8 @@
 """
 Test: Everything
 
-Version: 1.1.26
-Date updated: 14/04/2024 (dd/mm/yyyy)
+Version: 1.1.27
+Date updated: 01/02/2025 (dd/mm/yyyy)
 """
 
 # Library
@@ -103,6 +103,11 @@ from absfuyu.util.lunar import LunarCalendar
 from absfuyu.util.path import Directory, SaveFileAs
 from absfuyu.util.performance import Checker, function_debug, measure_performance, retry
 from absfuyu.util.pkl import Pickler
+from absfuyu.util.shorten_number import (
+    CommonUnitSuffixesFactory,
+    Decimal,
+    UnitSuffixFactory,
+)
 from absfuyu.util.zipped import Zipper
 from absfuyu.version import (
     Bumper,

{absfuyu-4.0.0 → absfuyu-4.1.0}/tests/test_tarot.py

@@ -1,8 +1,8 @@
 """
 Test: Tarot
 
-Version: 1.0.0
-Date updated: 27/11/2023 (dd/mm/yyyy)
+Version: 1.0.1
+Date updated: 16/01/2025 (dd/mm/yyyy)
 """
 
 # Library
@@ -15,4 +15,4 @@ from absfuyu.fun.tarot import Tarot, TarotCard
 # Test
 ###########################################################################
 def test_tarot():
-    assert type(Tarot().random_card()) == TarotCard
+    assert isinstance(Tarot().random_card(), TarotCard)

{absfuyu-4.0.0 → absfuyu-4.1.0}/tests/test_util.py

@@ -1,8 +1,8 @@
 """
 Test: Util
 
-Version: 1.1.0
-Date updated: 14/04/2024 (dd/mm/yyyy)
+Version: 1.2.0
+Date updated: 01/02/2025 (dd/mm/yyyy)
 """
 
 import sys
@@ -14,6 +14,7 @@ from absfuyu.util import set_max, set_min, set_min_max
 from absfuyu.util.api import APIRequest, PingResult, ping_windows
 from absfuyu.util.json_method import JsonFile
 from absfuyu.util.path import Directory
+from absfuyu.util.shorten_number import CommonUnitSuffixesFactory, Decimal
 
 
 # MARK: util
@@ -48,11 +49,13 @@ class TestUtilAPI:
             # No internet
             assert instance
 
+    @pytest.mark.skipif(
+        sys.platform not in ["win32", "cygwin"],
+        reason="Not applicable on Linux and MacOS",
+    )  # windows only
     def test_ping_windows(self) -> None:
-        if sys.platform in ["win32", "cygwin"]:  # windows only
-            res = ping_windows(["google.com"], 1)
-            assert isinstance(res[0], PingResult)
-        assert True
+        res = ping_windows(["google.com"], 1)
+        assert isinstance(res[0], PingResult)
 
 
 # MARK: json
@@ -74,3 +77,28 @@ class TestUtilPath:
     def test_list_structure(self) -> None:
         instance = Directory(source_path=CORE_PATH)
         assert instance.list_structure_pkg()
+
+
+# MARK: shorten number
+@pytest.mark.abs_util
+class TestUtilShortenNumber:
+    """absfuyu.util.shorten_number"""
+
+    @pytest.mark.parametrize(["value", "output"], [(1000, 1.0), (1000000, 1.0)])
+    def test_number(self, value: int | float, output: float) -> None:
+        ins = Decimal.number(value)
+        assert ins.value == output
+
+    def test_number2(self) -> None:
+        fac = CommonUnitSuffixesFactory.NUMBER
+        unit = 1
+        for i, suffix in enumerate(fac.short_name):
+            unit = fac.base**i
+            assert Decimal.number(unit).suffix == suffix
+
+    def test_data_size(self) -> None:
+        fac = CommonUnitSuffixesFactory.DATA_SIZE
+        unit = 1
+        for i, suffix in enumerate(fac.short_name):
+            unit = fac.base**i
+            assert Decimal.data_size(unit).suffix == suffix

{absfuyu-4.0.0 → absfuyu-4.1.0}/tests/test_version.py

@@ -6,7 +6,6 @@ Date updated: 06/04/2024 (dd/mm/yyyy)
 """
 
 from itertools import product
-from typing import List, Tuple, Union
 
 import pytest
 
@@ -20,10 +19,10 @@ class TestVersion:
     )
     def test_init(
         self,
-        major: Union[int, str],
-        minor: Union[int, str],
-        patch: Union[int, str],
-        serial: Union[int, str],
+        major: int | str,
+        minor: int | str,
+        patch: int | str,
+        serial: int | str,
     ) -> None:
         try:
             _ = Version(major, minor, patch, ReleaseLevel.DEV, serial)
@@ -71,24 +70,24 @@ class TestVersion:
 
 
 # Bumper
-def list_of_bumper_bump_test() -> (
-    List[Tuple[Tuple[int, int, int, str, int], str, str, str]]
-):
-    bumper_list: List[Tuple[int, int, int, str, int]] = [
+def list_of_bumper_bump_test() -> list[
+    tuple[tuple[int, int, int, str, int], str, str, str]
+]:
+    bumper_list: list[tuple[int, int, int, str, int]] = [
         (1, 0, 0, ReleaseLevel.FINAL, 0),
         (1, 3, 2, ReleaseLevel.FINAL, 0),
         (2, 4, 6, ReleaseLevel.RC, 0),
         (2, 4, 6, ReleaseLevel.DEV, 0),
     ]
-    release_options: List[str] = [
+    release_options: list[str] = [
         ReleaseOption.MAJOR,
         ReleaseOption.MINOR,
         ReleaseOption.PATCH,
     ]
-    release_levels: List[str] = [ReleaseLevel.FINAL, ReleaseLevel.DEV, ReleaseLevel.RC]
+    release_levels: list[str] = [ReleaseLevel.FINAL, ReleaseLevel.DEV, ReleaseLevel.RC]
     merged = list(product(bumper_list, release_options, release_levels))
     # TODO: Improve this
-    result_list: List[str] = [
+    result_list: list[str] = [
         # 1.0.0
         "2.0.0",  # major final
         "2.0.0.dev0",  # major dev
@@ -133,7 +132,7 @@ def list_of_bumper_bump_test() -> (
     if not len(result_list) == len(merged):
         # Check length
         raise ValueError("length of result_list is not in correct length")
-    out: List[Tuple[Bumper, str, str, str]] = [
+    out: list[tuple[Bumper, str, str, str]] = [
         (x[0], x[1], x[2], result_list[i]) for i, x in enumerate(merged)
     ]
     return out
@@ -146,7 +145,7 @@ class TestBumper:
     )
     def test_bump(
         self,
-        bumper: Tuple[int, int, int, str, int],
+        bumper: tuple[int, int, int, str, int],
         release_option: str,
         release_channel: str,
         desired_output: str,