py3-kit 0.0.8__py3-none-any.whl

py3_kit/__datetime.py

@@ -0,0 +1,23 @@
+import arrow
+
+
+def now(fmt: str = "YYYY-MM-DD HH:mm:ss") -> str:
+    return arrow.now().format(fmt)
+
+
+def delta(start_datetime_str: str, end_datetime_str: str) -> int:
+    """
+    >>> delta("2026-01-07 08:56:48","2026-01-07 13:00:00")
+    14592
+
+    Args:
+        start_datetime_str:
+        end_datetime_str:
+
+    Returns:
+
+    """
+    start_datetime = arrow.get(start_datetime_str).datetime
+    end_datetime = arrow.get(end_datetime_str).datetime
+    seconds = (end_datetime - start_datetime).total_seconds()
+    return int(seconds)

py3_kit/__init__.py

@@ -0,0 +1,35 @@
+from . import __datetime as datetime
+from . import __py3_execute__ as py3_execute
+from . import __py3_logger__ as py3_logger
+from . import __py3_web__ as py3_web
+from . import __string as string
+from . import _math as math
+from . import _pandas as pandas
+from . import _types as types
+from . import assets
+from . import file
+from . import image
+from . import list
+from . import pdf
+from . import project
+from . import sql
+from . import validators
+
+__all__ = [
+    "py3_execute",
+    "py3_logger",
+    "py3_web",
+    "datetime",
+    "string",
+    "math",
+    "pandas",
+    "types",
+    "assets",
+    "file",
+    "image",
+    "list",
+    "pdf",
+    "project",
+    "sql",
+    "validators",
+]

py3_kit/__py3_execute__/__init__.py

@@ -0,0 +1 @@
+from py3_execute import *

py3_kit/__py3_logger__/__init__.py

@@ -0,0 +1 @@
+from py3_logger import *

py3_kit/__py3_web__/__init__.py

@@ -0,0 +1 @@
+from py3_web import *

py3_kit/__string.py

@@ -0,0 +1,31 @@
+import re
+
+
+def camel_to_snake(string: str) -> str:
+    """
+    >>> camel_to_snake("camelToSnake")
+    'camel_to_snake'
+
+    Args:
+        string:
+
+    Returns:
+
+    """
+    string = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", string)
+    string = re.sub("([a-z0-9])([A-Z])", r"\1_\2", string).lower()
+    return string
+
+
+def snake_to_camel(string: str) -> str:
+    """
+    >>> snake_to_camel("snake_to_camel")
+    'SnakeToCamel'
+
+    Args:
+        string:
+
+    Returns:
+
+    """
+    return "".join(i.capitalize() for i in string.split("_"))

py3_kit/_math.py

@@ -0,0 +1,62 @@
+import math
+
+
+def int_ceil(num: float) -> int:
+    """
+    >>> int_ceil(10 / 3)
+    4
+
+    Args:
+        num:
+
+    Returns:
+
+    """
+    return math.ceil(num)
+
+
+def decimal_ceil(
+        num: float,
+        places: int = 2
+) -> float:
+    """
+    >>> decimal_ceil(3.14159)
+    3.15
+
+    Args:
+        num:
+        places:
+
+    Returns:
+
+    """
+    if places >= 0:
+        scale = 10.0 ** places
+        return math.ceil(num * scale) / scale
+    else:
+        raise ValueError(
+            f"Invalid value for 'places': "
+            f"Expected `int` and >= 0, "
+            f"but got value: {places!r}"
+        )
+
+
+def format_number(
+        number: int | float | str,
+        places: int = 2
+) -> str:
+    """
+    >>> format_number(3.1)
+    '3.10'
+
+    Args:
+        number:
+        places:
+
+    Returns:
+
+    """
+    integer_str, decimal_str = str(float(number)).split(".")
+    decimal_str = (decimal_str + "0" * (places - len(decimal_str)))[:places]
+    number_str = ".".join([integer_str, decimal_str])
+    return number_str

py3_kit/_pandas.py

@@ -0,0 +1,30 @@
+import pandas as pd
+
+
+def split(
+        df: pd.DataFrame,
+        num_parts: int | None = None,
+        part_size: int | None = None
+) -> list[pd.DataFrame]:
+    if df.empty:
+        return []
+
+    if num_parts:
+        avg_size = len(df) // num_parts
+        remainder = len(df) % num_parts
+
+        result = []
+        start = 0
+        for i in range(num_parts):
+            end = start + avg_size + (1 if i < remainder else 0)
+            result.append(df.iloc[start:end])
+            start = end
+        return result
+
+    elif part_size:
+        return [df.iloc[i:i + part_size] for i in range(0, len(df), part_size)]
+
+    else:
+        raise ValueError(
+            f"Either num_parts: {num_parts!r} or part_size: {part_size!r} must be provided"
+        )

py3_kit/_types.py

@@ -0,0 +1,50 @@
+from abc import ABCMeta
+from collections.abc import ItemsView, KeysView, ValuesView
+from types import new_class
+from typing import NamedTuple, cast
+
+import py3_kit
+
+
+class ViewClasses(NamedTuple):
+    ItemsView: type
+    KeysView: type
+    ValuesView: type
+
+
+def create_view_classes(class_name: str) -> ViewClasses:
+    def _create_view_classes(base_class: type) -> type:
+        name = f"{class_name}{base_class.__name__}"
+        return new_class(
+            name,
+            (base_class,),
+            exec_body=lambda ns: ns.update({
+                "__repr__": lambda self: f"{py3_kit.string.camel_to_snake(name)}({list(self)})"
+            })
+        )
+
+    return ViewClasses(
+        ItemsView=_create_view_classes(ItemsView),
+        KeysView=_create_view_classes(KeysView),
+        ValuesView=_create_view_classes(ValuesView),
+    )
+
+
+def create_subclasscheck_meta_class(
+        meta_class_name: str = "SubclasscheckMeta",
+        *,
+        required_all_methods: tuple[str, ...] = tuple(),
+        required_any_methods: tuple[str, ...] = tuple()
+) -> type[ABCMeta]:
+    return cast(type[ABCMeta], new_class(
+        meta_class_name,
+        (ABCMeta,),
+        exec_body=lambda ns: ns.update({
+            "__subclasscheck__": classmethod(
+                lambda cls, subclass:
+                all([callable(getattr(subclass, i, None)) for i in required_all_methods]) and
+                (any([callable(getattr(subclass, i, None)) for i in required_any_methods]) if required_any_methods
+                 else True)
+            )
+        })
+    ))

py3_kit/assets.py

@@ -0,0 +1,10 @@
+import inspect
+import os
+
+
+def get_assets_file_path(path: str) -> str:
+    assets_dir_path = os.path.splitext(os.path.abspath(__file__))[0]
+    caller_dir_path = os.path.splitext([str(frame_info.filename) for frame_info in inspect.stack()][1])[0]
+    mid_dir_path = os.path.relpath(caller_dir_path, assets_dir_path).lstrip(os.path.pardir + os.path.sep)
+    assets_file_path = os.path.join(assets_dir_path, mid_dir_path, path)
+    return assets_file_path

py3_kit/file.py

@@ -0,0 +1,209 @@
+"""
+rar
+    https://www.rarlab.com/download.htm
+
+7z
+    Windows: https://www.7-zip.org/a/7zr.exe
+    Darwin: https://www.7-zip.org/a/7z2501-mac.tar.xz
+    Linux: https://www.7-zip.org/a/7z2501-linux-x64.tar.xz
+"""
+import os
+import platform
+import subprocess
+import sys
+import zipfile
+from typing import Literal, cast
+
+import py3_kit
+
+COMPRESS_TYPE = Literal["zip", "rar", "7z"]
+DECOMPRESS_TYPE = Literal["zip", "rar", "7z"]
+
+
+def compress(
+        path: str,
+        compress_type: COMPRESS_TYPE | None = None,
+        compress_file_path: str | None = None
+) -> str | None:
+    path = os.path.abspath(path)
+
+    if compress_file_path is not None:
+        compress_file_path = os.path.abspath(compress_file_path)
+        if compress_type is None:
+            compress_type = os.path.splitext(compress_file_path)[-1][1:]
+    else:
+        if compress_type is None:
+            compress_type = "zip"
+        compress_file_path = os.path.join(
+            os.path.dirname(path), os.path.basename(path) + os.extsep + compress_type
+        )
+
+    if compress_type == "zip":
+        with zipfile.ZipFile(compress_file_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            if os.path.isdir(path):
+                for root, dirs, files in os.walk(path):
+                    for file in files:
+                        if (file_path := os.path.join(root, file)) == compress_file_path:
+                            continue
+                        rel_file_path = os.path.relpath(file_path, path)
+                        zf.write(file_path, arcname=rel_file_path)
+            else:
+                rel_file_path = os.path.basename(path)
+                zf.write(path, arcname=rel_file_path)
+        return compress_file_path
+
+    if compress_type == "rar":
+        if sys.platform.startswith("win"):
+            x = py3_kit.assets.get_assets_file_path(f"win{os.sep}Rar.exe")
+        elif sys.platform == "darwin":
+            x = py3_kit.assets.get_assets_file_path(f"mac{os.sep}rar")
+        elif sys.platform.startswith("linux"):
+            x = py3_kit.assets.get_assets_file_path(f"linux{os.sep}rar")
+        else:
+            return None
+        args = [
+            x,
+            "a",
+            "-r",
+            "-inul",
+            "-ep1",
+            compress_file_path
+        ]
+        if os.path.isdir(path):
+            args.append(f"{path}{os.sep}*")
+        else:
+            args.append(path)
+        if subprocess.run(args).returncode == 0:
+            return compress_file_path
+
+    if compress_type == "7z":
+        if sys.platform.startswith("win"):
+            x = py3_kit.assets.get_assets_file_path(f"win{os.sep}7zr.exe")
+        elif sys.platform == "darwin":
+            x = py3_kit.assets.get_assets_file_path(f"mac{os.sep}7zz")
+        elif sys.platform.startswith("linux"):
+            x = py3_kit.assets.get_assets_file_path(f"linux{os.sep}7zz")
+        else:
+            return None
+        args = [
+            x,
+            "a",
+            compress_file_path
+        ]
+        if os.path.isdir(path):
+            args.append(f"{path}{os.sep}*")
+        else:
+            args.append(path)
+        args.extend("-bb0 -bso0 -bsp0 -bse0".split())
+        if subprocess.run(args).returncode == 0:
+            return compress_file_path
+
+    return None
+
+
+def decompress(
+        compress_file_path: str,
+        path: str | None = None
+) -> str | None:
+    compress_file_path = os.path.abspath(compress_file_path)
+    if not os.path.isfile(compress_file_path):
+        return None
+
+    if path is not None:
+        path = os.path.abspath(path)
+    else:
+        path = os.path.dirname(compress_file_path)
+    os.makedirs(path, exist_ok=True)
+
+    with open(compress_file_path, "rb") as file:
+        data = file.read(8)
+    text = data.hex()
+    if text in ("504b030414000000",):
+        decompress_type = "zip"
+    elif text in ("526172211a070100", "526172211a0700cf"):
+        decompress_type = "rar"
+    elif text in ('377abcaf271c0004',):
+        decompress_type = "7z"
+    else:
+        return None
+
+    if decompress_type == "zip":
+        with zipfile.ZipFile(compress_file_path, "r") as zf:
+            zf.extractall(path)
+        return path
+
+    if decompress_type == "rar":
+        if sys.platform.startswith("win"):
+            x = py3_kit.assets.get_assets_file_path(f"win{os.sep}UnRAR.exe")
+        elif sys.platform == "darwin":
+            x = py3_kit.assets.get_assets_file_path(f"mac{os.sep}unrar")
+        elif sys.platform.startswith("linux"):
+            x = py3_kit.assets.get_assets_file_path(f"linux{os.sep}unrar")
+        else:
+            return None
+        args = [
+            x,
+            "x",
+            "-o+",
+            "-inul",
+            compress_file_path,
+            path
+        ]
+        if subprocess.run(args).returncode == 0:
+            return path
+
+    if decompress_type == "7z":
+        if sys.platform.startswith("win"):
+            x = py3_kit.assets.get_assets_file_path(f"win{os.sep}7zr.exe")
+        elif sys.platform == "darwin":
+            x = py3_kit.assets.get_assets_file_path(f"mac{os.sep}7zz")
+        elif sys.platform.startswith("linux"):
+            x = py3_kit.assets.get_assets_file_path(f"linux{os.sep}7zz")
+        else:
+            return None
+        args = [
+            x,
+            "x",
+            compress_file_path,
+            f"-o{path}",
+            "-y"
+        ]
+        args.extend("-bb0 -bso0 -bsp0 -bse0".split())
+        if subprocess.run(args).returncode == 0:
+            return path
+
+    return None
+
+
+def get_file_paths_and_dir_paths(path: str) -> tuple[list[str], list[str]]:
+    file_paths = []
+    dir_paths = []
+
+    path = os.path.abspath(path)
+    with os.scandir(path) as entries:
+        for entry in entries:
+            System = Literal["Windows", "Linux", "Darwin"]
+            system: System = cast(System, platform.system())
+            if system == "Windows":
+                from nt import DirEntry
+            elif system == "Linux":
+                from posix import DirEntry
+            elif system == "Darwin":
+                from posix import DirEntry
+            else:
+                raise TypeError(
+                    f"Invalid type for 'system': "
+                    f"Expected `Literal[\"Windows\",\"Linux\",\"Darwin\"]`, "
+                    f"but got {type(system).__name__!r} (value: {system!r})"
+                )
+
+            entry: DirEntry
+            if entry.is_file():
+                file_paths.append(entry.path)
+            elif entry.is_dir():
+                dir_paths.append(entry.path)
+                sub_file_paths, sub_dir_paths = get_file_paths_and_dir_paths(entry.path)
+                file_paths.extend(sub_file_paths)
+                dir_paths.extend(sub_dir_paths)
+
+    return file_paths, dir_paths

py3_kit/image.py

@@ -0,0 +1,139 @@
+import os
+from tempfile import NamedTemporaryFile
+from typing import Literal
+
+import cv2
+import numpy as np
+import pillow_avif  # type: ignore
+from PIL import Image
+
+
+def to_jpg(
+        image_file_path: str,
+        /,
+        jpg_file_path: str | None = None,
+        quality: int = 100,
+        keep_original: bool = False
+) -> str | None:
+    try:
+        with open(image_file_path, "rb") as file:
+            prefix_text = file.read(3).hex()
+            n = 2
+            file.seek(-n, 2)
+            suffix_text = file.read(n).hex()
+            text = prefix_text + suffix_text
+
+        image_file_path = os.path.abspath(image_file_path)
+        if jpg_file_path is not None:
+            jpg_file_path = os.path.abspath(jpg_file_path)
+        else:
+            jpg_file_path = os.path.splitext(image_file_path)[0] + os.path.extsep + "jpg"
+
+        if image_file_path == jpg_file_path and text == "ffd8ffffd9":
+            return jpg_file_path
+
+        jpg_dir_path = os.path.dirname(jpg_file_path)
+        os.makedirs(jpg_dir_path, exist_ok=True)
+
+        with Image.open(image_file_path) as image:
+            if image.mode in ("RGBA", "LA"):
+                background = Image.new("RGB", image.size, (255, 255, 255))
+                background.paste(image, mask=image.split()[-1])
+                image = background
+            elif image.mode == "P":
+                image.seek(0)  # image.n_frames
+                image = image.convert("RGB")
+            elif image.mode == "RGB":
+                pass
+            else:
+                return None
+
+            with NamedTemporaryFile(suffix=os.path.extsep + "jpg", delete=False, dir=jpg_dir_path) as ntf:
+                temp_file_path = ntf.name
+                image.save(temp_file_path, "JPEG", quality=quality)
+            os.replace(temp_file_path, jpg_file_path)
+
+        if not keep_original:
+            from pathlib import Path
+            if (
+                    jpg_file_path != image_file_path and
+                    (p := Path(image_file_path)).exists() and
+                    str(p.resolve()) == str(p.absolute())
+            ):
+                os.remove(image_file_path)
+
+        return jpg_file_path
+    except Exception as e:  # noqa
+        return None
+
+
+def resize(image: cv2.typing.MatLike, new_w: int, new_h: int) -> cv2.typing.MatLike:
+    return cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+
+def concat(
+        input_image_file_paths: list[str],
+        output_image_file_path: str,
+        orientation: Literal["vertical", "horizontal"] = "vertical",
+        output_image_vertical_width: int | float | None = None,
+        output_image_horizontal_height: int | float | None = None
+) -> bool:
+    try:
+        input_images = [cv2.imread(i, cv2.IMREAD_UNCHANGED) for i in input_image_file_paths]
+
+        if any(i is None for i in input_images):
+            return False
+
+        if orientation == "vertical":
+            if output_image_vertical_width is None:
+                output_image_vertical_width = min(i.shape[1] for i in input_images)
+
+            resized_images = []
+            for i in input_images:
+                h, w = i.shape[:2]
+                new_w = int(output_image_vertical_width)
+                new_h = int(h * new_w / w)
+                resized_image = resize(i, new_w, new_h)
+                resized_images.append(resized_image)
+
+            output_image_height = sum(i.shape[0] for i in resized_images)
+
+            output_image = np.ones((output_image_height, output_image_vertical_width, 3), dtype=np.uint8) * 255
+
+            y = 0
+            for i in resized_images:
+                h = i.shape[0]
+                output_image[y:y + h, :i.shape[1]] = i
+                y += h
+
+            return cv2.imwrite(output_image_file_path, output_image)
+
+        elif orientation == "horizontal":
+            if output_image_horizontal_height is None:
+                output_image_horizontal_height = min(i.shape[0] for i in input_images)
+
+            resized_images = []
+            for i in input_images:
+                h, w = i.shape[:2]
+                new_h = int(output_image_horizontal_height)
+                new_w = int(w * new_h / h)
+                resized_image = resize(i, new_w, new_h)
+                resized_images.append(resized_image)
+
+            output_image_width = sum(i.shape[1] for i in resized_images)
+
+            output_image = np.ones((output_image_horizontal_height, output_image_width, 3), dtype=np.uint8) * 255
+
+            x = 0
+            for i in resized_images:
+                w = i.shape[1]
+                output_image[:i.shape[0], x:x + w] = i
+                x += w
+
+            return cv2.imwrite(output_image_file_path, output_image)
+
+        else:
+            return False
+
+    except Exception as e:  # noqa
+        return False

py3_kit/list.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+
+def split(
+        data: list[Any],
+        num_parts: int | None = None,
+        part_size: int | None = None
+) -> list[Any]:
+    if not data:
+        return []
+
+    if num_parts:
+        avg_size = len(data) // num_parts
+        remainder = len(data) % num_parts
+
+        result = []
+        result.extend(
+            [data[start:start + avg_size] for start in range(0, len(data) - avg_size - remainder, avg_size)])
+        result.append(data[len(data) - avg_size - remainder:])
+        return result
+
+    elif part_size:
+        return [data[i:i + part_size] for i in range(0, len(data), part_size)]
+
+    else:
+        raise ValueError(
+            f"Either num_parts: {num_parts!r} or part_size: {part_size!r} must be provided"
+        )
+
+
+def flatten(data: list[Any]) -> list[Any]:
+    return sum((flatten(x) if isinstance(x, list) else [x] for x in data), [])

py3_kit/pdf.py

@@ -0,0 +1,20 @@
+from pypdf import PdfWriter
+
+
+def concat(
+        input_pdf_file_paths: list[str],
+        output_pdf_file_path: str
+) -> bool:
+    try:
+        writer = PdfWriter()
+
+        for input_pdf_file_path in input_pdf_file_paths:
+            writer.append(input_pdf_file_path)
+
+        with open(output_pdf_file_path, "wb") as f:
+            writer.write(f)
+
+        return True
+
+    except Exception:  # noqa
+        return False

py3_kit/project.py

@@ -0,0 +1,58 @@
+import hashlib
+from typing import Any, Literal
+
+ALGO_TYPE = Literal[
+    "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "blake2b", "blake2s", "sha3_224", "sha3_256", "sha3_384",
+    "sha3_512"
+]
+
+
+def gen_data_id(
+        *args: Any,
+        keys: list | None = None, item: dict | None = None,
+        algo_type: ALGO_TYPE = "sha256",
+        encoding: str = "utf-8"
+) -> str:
+    """
+    >>> gen_data_id("123456")
+    '8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c92'
+
+    Args:
+        *args:
+        keys:
+        item:
+        algo_type:
+        encoding:
+
+    Returns:
+
+    """
+    m = hashlib.new(algo_type)
+    if args:
+        values = args
+    elif keys is not None and item is not None:
+        if isinstance(keys, list) and isinstance(item, dict):
+            values = [item[k] for k in keys if k in item]
+        else:
+            raise TypeError(
+                f"Invalid type for 'keys': "
+                f"Expected `list | None`, "
+                f"but got {type(keys).__name__} (value: {keys!r})\n"
+                f"Invalid type for 'item': "
+                f"Expected `dict | None`, "
+                f"but got {type(item).__name__} (value: {item!r})"
+            )
+    elif item is not None:
+        values = [item[k] for k in sorted(item.keys())]
+    else:
+        raise ValueError(
+            f"Either args: {args!r} or keys: {keys!r} and item: {item!r} or item: {item!r} must be provided"
+        )
+
+    data = list(map(lambda x: str(x), values))
+
+    for i in data:
+        m.update(i.encode(encoding))
+
+    data_id = m.hexdigest()
+    return data_id

py3_kit/sql.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+import sqlparse
+
+
+def format(sql: str, **kwargs: Any) -> str:  # noqa
+    if not kwargs:
+        kwargs = dict(
+            reindent=True,
+            keyword_case="upper",
+            identifier_case="lower",
+            strip_comments=True
+        )
+    sql = sqlparse.format(sql, **kwargs)
+    return sql

py3_kit/validators.py

@@ -0,0 +1,21 @@
+from typing import Any, TypeGuard
+
+
+def is_bool(obj: Any) -> TypeGuard[bool]:
+    return isinstance(obj, bool)
+
+
+def is_int(obj: Any) -> TypeGuard[int]:
+    return isinstance(obj, int) and not isinstance(obj, bool)
+
+
+def is_str(val: Any) -> TypeGuard[str]:
+    return isinstance(val, str)
+
+
+def is_list(val: Any) -> TypeGuard[list[Any]]:
+    return isinstance(val, list)
+
+
+def is_list_of[T](val: list[Any], ele_type: type[T]) -> TypeGuard[list[T]]:
+    return isinstance(val, list) and all(isinstance(i, ele_type) for i in val)

py3_kit-0.0.8.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: py3-kit
+Version: 0.0.8
+Summary: python3 kit
+License-File: LICENSE
+Author: mathewgeola
+Author-email: mathewgeola@gmail.com
+Requires-Python: >=3.12,<3.15
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: arrow (>=1.4.0,<2.0.0)
+Requires-Dist: opencv-python (>=4.12.0.88,<5.0.0.0)
+Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
+Requires-Dist: oss2 (>=2.19.1,<3.0.0)
+Requires-Dist: pandas (>=2.3.3,<3.0.0)
+Requires-Dist: pillow (>=12.1.0,<13.0.0)
+Requires-Dist: pillow-avif-plugin (>=1.5.2,<2.0.0)
+Requires-Dist: py3-database (>=0.0.1,<0.0.2)
+Requires-Dist: py3-execute (>=0.0.5,<0.0.6)
+Requires-Dist: py3-logger (>=0.0.7,<0.0.8)
+Requires-Dist: py3-web (>=0.0.7,<0.0.8)
+Requires-Dist: pyinstaller (>=6.17.0,<7.0.0)
+Requires-Dist: pypdf (>=6.6.0,<7.0.0)
+Requires-Dist: sqlparse (>=0.5.5,<0.6.0)
+Description-Content-Type: text/markdown
+
+# py3-kit
+python3 kit
+

py3_kit-0.0.8.dist-info/RECORD

@@ -0,0 +1,31 @@
+py3_kit/__datetime.py,sha256=MtkjvQv66TZh3g2ZEg2pFHUwU92oFwNujxkwmZZdsbo,535
+py3_kit/__init__.py,sha256=LvOX65s7uPofdb3rXnCZFT5yfd9oZYrF0qh8RDa1pI0,689
+py3_kit/__py3_execute__/__init__.py,sha256=VzgVjDvegZNaPuoBCr4_C8E7AiJH1IX70K5Qniypj7E,26
+py3_kit/__py3_logger__/__init__.py,sha256=JmgoHRpIoPg0IgMRf-FAw4BCy9_NgbK7GembF_GP9sA,25
+py3_kit/__py3_web__/__init__.py,sha256=yZ9iRIrSy6gGWuOhbIltQQem89XimM4xc6C-cPf1PTA,22
+py3_kit/__string.py,sha256=o-mcgc3NTVJPdtvARkOCX8-8ekUqF_OyTmpyObgbgQU,535
+py3_kit/_math.py,sha256=q19pDrndfysgAnU8KisgBUyr6SjiajV9j6v6Lbs1sFE,1030
+py3_kit/_pandas.py,sha256=EXxLPcgcxAB87EsPo07ysEYQh0cbUR2Bo0ByhnfhsQ8,764
+py3_kit/_types.py,sha256=ran8qyJDCf8gdwrZtDVDrQ8GFj5YtjEHJB2hQmBxV_Q,1561
+py3_kit/assets/file/linux/7zz,sha256=oYYP3w1uw5Xg4nflIi6apIh0fbSqXIfR7IeaCRa6Cy8,2878000
+py3_kit/assets/file/linux/7zzs,sha256=XvVvvvRKm2GANqkAOdSnCaGOCVDXk5ESEU9cQ2dMVCI,3759224
+py3_kit/assets/file/linux/rar,sha256=ydystOHpMTvhHjcK23kbBjAt0LMUD63UBuY8V1gmPsU,798760
+py3_kit/assets/file/linux/unrar,sha256=9BC4PJQvBkecCqIoIegsXLSErC1rP0FoR8LwdLSPFCM,441632
+py3_kit/assets/file/mac/7zz,sha256=XC_TbwCmb3eH3PG63Zd9RKArUAY_5WeOHxn_ZHl0Mu0,5885696
+py3_kit/assets/file/mac/rar,sha256=V6NgbJLR1mmLWWpeg_z77nFdfnLF-IR_kFAe2vP_XqE,693296
+py3_kit/assets/file/mac/unrar,sha256=kR1GMUZ-Y-GoB2Q_YSs_-x-HrpHT1P5ISK9KhuVk4Qc,393992
+py3_kit/assets/file/win/7zr.exe,sha256=J8vj1YBK0J6Qu8qpFtoNXDsL6UYtDg-2y1S-XtkDCHU,601088
+py3_kit/assets/file/win/Rar.exe,sha256=cgpIHEQSHKuHDC5sVIMR2Qkt2X9nwpSVFoltI0vlbx4,822480
+py3_kit/assets/file/win/UnRAR.exe,sha256=i8LtOnNL6ekMY_Os9q3Pbh8eZN28ZkPOIZDQQB2Y77U,548560
+py3_kit/assets.py,sha256=WrrsPhrqX1i6lGVdbm_1Xgvvj-ViBbyWPJVmn7GFFRI,454
+py3_kit/file.py,sha256=_xBsDqEB6imYg-P5dKRkgilFiRf9rtkWr4cFjAA9bQk,6765
+py3_kit/image.py,sha256=TnDZTt-nTQV0NSqzWlAOTOLXMLRErDBkmdzJOfr9i1U,4809
+py3_kit/list.py,sha256=ZBrvUsFcBIF41Juy_qInwuyZOOL8m4snXSLDS3pPe-A,892
+py3_kit/pdf.py,sha256=zWrhf09N8DwbHOVBAzFqzW5voCXzDIKXcNEmHMxVFcw,425
+py3_kit/project.py,sha256=tCwV6m3JZUmorBFW2kxVm5w4DWj_lUaMISjXMnhRT0Q,1604
+py3_kit/sql.py,sha256=z6I7-AHuxJo6QeRrK4L7lnrT_VOn9tAwoquy-vDgAnY,332
+py3_kit/validators.py,sha256=SWGVUv8ACrAMihVjVM7hSjTEQA0rNV3ScPFHsvQO3CY,528
+py3_kit-0.0.8.dist-info/METADATA,sha256=5b7Ol89ZI5xao6uTtCG4uu2_SxqnRXBO65UCDcmAnM8,1041
+py3_kit-0.0.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+py3_kit-0.0.8.dist-info/licenses/LICENSE,sha256=l9yqPB-E89lQPmUwybOix3aliW6hox6ZY14E0CnXK6c,1068
+py3_kit-0.0.8.dist-info/RECORD,,

py3_kit-0.0.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

py3_kit-0.0.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mathewgeola
+
+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.