pyrubix 1.0.0__tar.gz

pyrubix-1.0.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: pyrubix
+Version: 1.0.0
+Summary: Powerful lightweight Python utility library
+Project-URL: Homepage, https://xnovear.dpdns.org
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ULIB
+
+Lightweight Python utility library.
+
+Version: 3.0.0
+
+## Features
+
+- Math
+- Text
+- JSON
+- System
+- Time
+- Cache
+- Retry
+- Timer
+- File utilities
+- Subprocess
+- Hash
+- UUID
+- Random
+- Collections
+- Network
+- Logging
+
+## Install
+
+python -m pip install -e .
+
+## Example
+
+import ulib
+
+print(ulib.add(10, 20))
+print(ulib.sha256("hello"))
+print(ulib.uuid())
+
+result = ulib.run("ls -la")
+print(result.stdout)

pyrubix-1.0.0/README.md

@@ -0,0 +1,39 @@
+# ULIB
+
+Lightweight Python utility library.
+
+Version: 3.0.0
+
+## Features
+
+- Math
+- Text
+- JSON
+- System
+- Time
+- Cache
+- Retry
+- Timer
+- File utilities
+- Subprocess
+- Hash
+- UUID
+- Random
+- Collections
+- Network
+- Logging
+
+## Install
+
+python -m pip install -e .
+
+## Example
+
+import ulib
+
+print(ulib.add(10, 20))
+print(ulib.sha256("hello"))
+print(ulib.uuid())
+
+result = ulib.run("ls -la")
+print(result.stdout)

pyrubix-1.0.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyrubix"
+version = "1.0.0"
+description = "Powerful lightweight Python utility library"
+readme = "README.md"
+requires-python = ">=3.9"
+
+[project.urls]
+Homepage = "https://xnovear.dpdns.org"

pyrubix-1.0.0/pyrubix.egg-info/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: pyrubix
+Version: 1.0.0
+Summary: Powerful lightweight Python utility library
+Project-URL: Homepage, https://xnovear.dpdns.org
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# ULIB
+
+Lightweight Python utility library.
+
+Version: 3.0.0
+
+## Features
+
+- Math
+- Text
+- JSON
+- System
+- Time
+- Cache
+- Retry
+- Timer
+- File utilities
+- Subprocess
+- Hash
+- UUID
+- Random
+- Collections
+- Network
+- Logging
+
+## Install
+
+python -m pip install -e .
+
+## Example
+
+import ulib
+
+print(ulib.add(10, 20))
+print(ulib.sha256("hello"))
+print(ulib.uuid())
+
+result = ulib.run("ls -la")
+print(result.stdout)

pyrubix-1.0.0/pyrubix.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+pyrubix.egg-info/PKG-INFO
+pyrubix.egg-info/SOURCES.txt
+pyrubix.egg-info/dependency_links.txt
+pyrubix.egg-info/top_level.txt
+ulib/__init__.py
+ulib/cache.py
+ulib/collections.py
+ulib/crypto.py
+ulib/decorators.py
+ulib/fileutil.py
+ulib/identity.py
+ulib/jsonx.py
+ulib/loggingx.py
+ulib/math.py
+ulib/network.py
+ulib/process.py
+ulib/randomutil.py
+ulib/system.py
+ulib/text.py
+ulib/timeutil.py

pyrubix-1.0.0/pyrubix.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyrubix-1.0.0/pyrubix.egg-info/top_level.txt

@@ -0,0 +1 @@
+ulib

pyrubix-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyrubix-1.0.0/ulib/__init__.py

@@ -0,0 +1,221 @@
+from .math import (
+    add,
+    subtract,
+    multiply,
+    divide,
+    power,
+    average,
+    median,
+    clamp,
+    percentage,
+    lerp,
+    map_range,
+    factorial,
+    gcd,
+    lcm,
+)
+
+from .text import (
+    reverse,
+    is_palindrome,
+    word_count,
+    char_count,
+    slugify,
+    truncate,
+    camel_case,
+    snake_case,
+    clean,
+    remove_spaces,
+    is_email,
+    is_url,
+    is_number,
+)
+
+from .jsonx import (
+    dumps,
+    loads,
+    save,
+    load,
+)
+
+from .system import (
+    platform,
+    python_version,
+    cpu_count,
+    memory_usage,
+    env,
+    set_env,
+    which,
+)
+
+from .timeutil import (
+    now,
+    timestamp,
+    elapsed,
+    sleep,
+)
+
+from .cache import (
+    memoize,
+    TTLCache,
+)
+
+from .decorators import (
+    timer,
+    retry,
+)
+
+from .fileutil import (
+    read_text,
+    write_text,
+    read_bytes,
+    write_bytes,
+    exists,
+    is_file,
+    is_dir,
+    file_size,
+    copy,
+    move,
+    remove,
+    mkdir,
+    listdir,
+)
+
+from .process import (
+    run,
+)
+
+from .crypto import (
+    md5,
+    sha256,
+    sha512,
+    file_md5,
+    file_sha256,
+    file_sha512,
+)
+
+from .identity import (
+    uuid,
+    short_uuid,
+)
+
+from .randomutil import (
+    random_int,
+    random_float,
+    random_choice,
+    random_string,
+)
+
+from .collections import (
+    chunk,
+    flatten,
+    unique,
+)
+
+from .network import (
+    is_online,
+    ping,
+    get_public_ip,
+)
+
+from .loggingx import (
+    log,
+)
+
+__version__ = "3.0.0"
+
+__all__ = [
+    "add",
+    "subtract",
+    "multiply",
+    "divide",
+    "power",
+    "average",
+    "median",
+    "clamp",
+    "percentage",
+    "lerp",
+    "map_range",
+    "factorial",
+    "gcd",
+    "lcm",
+
+    "reverse",
+    "is_palindrome",
+    "word_count",
+    "char_count",
+    "slugify",
+    "truncate",
+    "camel_case",
+    "snake_case",
+    "clean",
+    "remove_spaces",
+    "is_email",
+    "is_url",
+    "is_number",
+
+    "dumps",
+    "loads",
+    "save",
+    "load",
+
+    "platform",
+    "python_version",
+    "cpu_count",
+    "memory_usage",
+    "env",
+    "set_env",
+    "which",
+
+    "now",
+    "timestamp",
+    "elapsed",
+    "sleep",
+
+    "memoize",
+    "TTLCache",
+
+    "timer",
+    "retry",
+
+    "read_text",
+    "write_text",
+    "read_bytes",
+    "write_bytes",
+    "exists",
+    "is_file",
+    "is_dir",
+    "file_size",
+    "copy",
+    "move",
+    "remove",
+    "mkdir",
+    "listdir",
+
+    "run",
+
+    "md5",
+    "sha256",
+    "sha512",
+    "file_md5",
+    "file_sha256",
+    "file_sha512",
+
+    "uuid",
+    "short_uuid",
+
+    "random_int",
+    "random_float",
+    "random_choice",
+    "random_string",
+
+    "chunk",
+    "flatten",
+    "unique",
+
+    "is_online",
+    "ping",
+    "get_public_ip",
+
+    "log",
+]

pyrubix-1.0.0/ulib/cache.py

@@ -0,0 +1,73 @@
+import time
+from functools import wraps
+
+
+def memoize(func):
+    cache = {}
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        key = (
+            args,
+            tuple(sorted(kwargs.items())),
+        )
+
+        if key not in cache:
+            cache[key] = func(*args, **kwargs)
+
+        return cache[key]
+
+    wrapper.cache = cache
+
+    return wrapper
+
+
+class TTLCache:
+    def __init__(self, ttl=60):
+        if ttl < 0:
+            raise ValueError("ttl cannot be negative")
+
+        self.ttl = ttl
+        self._data = {}
+
+    def set(self, key, value):
+        self._data[key] = (
+            value,
+            time.monotonic() + self.ttl,
+        )
+
+    def get(self, key, default=None):
+        item = self._data.get(key)
+
+        if item is None:
+            return default
+
+        value, expires = item
+
+        if time.monotonic() >= expires:
+            self._data.pop(key, None)
+            return default
+
+        return value
+
+    def delete(self, key):
+        self._data.pop(key, None)
+
+    def clear(self):
+        self._data.clear()
+
+    def __len__(self):
+        self._cleanup()
+        return len(self._data)
+
+    def _cleanup(self):
+        current = time.monotonic()
+
+        expired = [
+            key
+            for key, (_, expires) in self._data.items()
+            if current >= expires
+        ]
+
+        for key in expired:
+            self._data.pop(key, None)

pyrubix-1.0.0/ulib/collections.py

@@ -0,0 +1,41 @@
+def chunk(values, size):
+    if size <= 0:
+        raise ValueError("size must be greater than zero")
+
+    values = list(values)
+
+    return [
+        values[i:i + size]
+        for i in range(0, len(values), size)
+    ]
+
+
+def flatten(values):
+    result = []
+
+    for item in values:
+        if isinstance(item, (list, tuple)):
+            result.extend(flatten(item))
+        else:
+            result.append(item)
+
+    return result
+
+
+def unique(values):
+    result = []
+    seen = set()
+
+    for item in values:
+        try:
+            key = item
+
+            if key not in seen:
+                seen.add(key)
+                result.append(item)
+
+        except TypeError:
+            if item not in result:
+                result.append(item)
+
+    return result

pyrubix-1.0.0/ulib/crypto.py

@@ -0,0 +1,47 @@
+import hashlib
+
+
+def _hash_text(text, algorithm):
+    return hashlib.new(
+        algorithm,
+        str(text).encode("utf-8"),
+    ).hexdigest()
+
+
+def md5(text):
+    return _hash_text(text, "md5")
+
+
+def sha256(text):
+    return _hash_text(text, "sha256")
+
+
+def sha512(text):
+    return _hash_text(text, "sha512")
+
+
+def _hash_file(path, algorithm, chunk_size=1024 * 1024):
+    h = hashlib.new(algorithm)
+
+    with open(path, "rb") as f:
+        while True:
+            chunk = f.read(chunk_size)
+
+            if not chunk:
+                break
+
+            h.update(chunk)
+
+    return h.hexdigest()
+
+
+def file_md5(path):
+    return _hash_file(path, "md5")
+
+
+def file_sha256(path):
+    return _hash_file(path, "sha256")
+
+
+def file_sha512(path):
+    return _hash_file(path, "sha512")

pyrubix-1.0.0/ulib/decorators.py

@@ -0,0 +1,50 @@
+import time
+from functools import wraps
+
+
+def timer(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start = time.perf_counter()
+
+        try:
+            return func(*args, **kwargs)
+        finally:
+            elapsed = time.perf_counter() - start
+            print(f"[ULIB] {func.__name__}: {elapsed:.6f}s")
+
+    return wrapper
+
+
+def retry(
+    attempts=3,
+    delay=0,
+    exceptions=(Exception,),
+):
+    if attempts < 1:
+        raise ValueError("attempts must be >= 1")
+
+    if delay < 0:
+        raise ValueError("delay cannot be negative")
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            last_error = None
+
+            for attempt in range(attempts):
+                try:
+                    return func(*args, **kwargs)
+
+                except exceptions as error:
+                    last_error = error
+
+                    if attempt < attempts - 1:
+                        if delay:
+                            time.sleep(delay)
+
+            raise last_error
+
+        return wrapper
+
+    return decorator

pyrubix-1.0.0/ulib/fileutil.py

@@ -0,0 +1,61 @@
+import os
+import shutil
+
+
+def read_text(path, encoding="utf-8"):
+    with open(path, "r", encoding=encoding) as f:
+        return f.read()
+
+
+def write_text(path, text, encoding="utf-8"):
+    with open(path, "w", encoding=encoding) as f:
+        f.write(str(text))
+
+
+def read_bytes(path):
+    with open(path, "rb") as f:
+        return f.read()
+
+
+def write_bytes(path, data):
+    with open(path, "wb") as f:
+        f.write(data)
+
+
+def exists(path):
+    return os.path.exists(path)
+
+
+def is_file(path):
+    return os.path.isfile(path)
+
+
+def is_dir(path):
+    return os.path.isdir(path)
+
+
+def file_size(path):
+    return os.path.getsize(path)
+
+
+def copy(src, dst):
+    return shutil.copy2(src, dst)
+
+
+def move(src, dst):
+    return shutil.move(src, dst)
+
+
+def remove(path):
+    if os.path.isdir(path) and not os.path.islink(path):
+        shutil.rmtree(path)
+    else:
+        os.remove(path)
+
+
+def mkdir(path, parents=True, exist_ok=True):
+    os.makedirs(path, exist_ok=exist_ok) if parents else os.mkdir(path)
+
+
+def listdir(path="."):
+    return os.listdir(path)

pyrubix-1.0.0/ulib/identity.py

@@ -0,0 +1,9 @@
+import uuid as _uuid
+
+
+def uuid():
+    return str(_uuid.uuid4())
+
+
+def short_uuid():
+    return _uuid.uuid4().hex[:12]

pyrubix-1.0.0/ulib/jsonx.py

@@ -0,0 +1,28 @@
+import json
+
+
+def dumps(obj, indent=2, ensure_ascii=False):
+    return json.dumps(
+        obj,
+        indent=indent,
+        ensure_ascii=ensure_ascii,
+    )
+
+
+def loads(text):
+    return json.loads(text)
+
+
+def save(obj, path, indent=2):
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(
+            obj,
+            f,
+            indent=indent,
+            ensure_ascii=False,
+        )
+
+
+def load(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)

pyrubix-1.0.0/ulib/loggingx.py

@@ -0,0 +1,9 @@
+import datetime
+
+
+def log(message, level="INFO"):
+    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    print(
+        f"[{now}] [{str(level).upper()}] {message}"
+    )

pyrubix-1.0.0/ulib/math.py

@@ -0,0 +1,83 @@
+import math
+
+
+def add(a, b):
+    return a + b
+
+
+def subtract(a, b):
+    return a - b
+
+
+def multiply(a, b):
+    return a * b
+
+
+def divide(a, b):
+    if b == 0:
+        raise ZeroDivisionError("cannot divide by zero")
+    return a / b
+
+
+def power(a, b):
+    return a ** b
+
+
+def average(values):
+    values = list(values)
+
+    if not values:
+        raise ValueError("values cannot be empty")
+
+    return sum(values) / len(values)
+
+
+def median(values):
+    values = sorted(values)
+
+    if not values:
+        raise ValueError("values cannot be empty")
+
+    return math.median(values)
+
+
+def clamp(value, minimum, maximum):
+    if minimum > maximum:
+        raise ValueError("minimum cannot be greater than maximum")
+
+    return max(minimum, min(value, maximum))
+
+
+def percentage(value, total):
+    if total == 0:
+        raise ZeroDivisionError("total cannot be zero")
+
+    return value / total * 100
+
+
+def lerp(a, b, t):
+    return a + (b - a) * t
+
+
+def map_range(value, in_min, in_max, out_min, out_max):
+    if in_min == in_max:
+        raise ValueError("input range cannot be zero")
+
+    return (
+        (value - in_min)
+        * (out_max - out_min)
+        / (in_max - in_min)
+        + out_min
+    )
+
+
+def factorial(n):
+    return math.factorial(n)
+
+
+def gcd(a, b):
+    return math.gcd(a, b)
+
+
+def lcm(a, b):
+    return math.lcm(a, b)

pyrubix-1.0.0/ulib/network.py

@@ -0,0 +1,41 @@
+import socket
+import urllib.request
+
+
+def is_online(timeout=3):
+    try:
+        with socket.create_connection(
+            ("1.1.1.1", 53),
+            timeout=timeout,
+        ):
+            return True
+
+    except OSError:
+        return False
+
+
+def ping(host, port=80, timeout=3):
+    try:
+        with socket.create_connection(
+            (host, port),
+            timeout=timeout,
+        ):
+            return True
+
+    except OSError:
+        return False
+
+
+def get_public_ip(timeout=5):
+    request = urllib.request.Request(
+        "https://api.ipify.org",
+        headers={
+            "User-Agent": "ulib/3.0",
+        },
+    )
+
+    with urllib.request.urlopen(
+        request,
+        timeout=timeout,
+    ) as response:
+        return response.read().decode("utf-8").strip()

pyrubix-1.0.0/ulib/process.py

@@ -0,0 +1,22 @@
+import subprocess
+
+
+def run(
+    command,
+    *,
+    shell=True,
+    check=False,
+    capture=True,
+    text=True,
+    timeout=None,
+):
+    result = subprocess.run(
+        command,
+        shell=shell,
+        check=check,
+        capture_output=capture,
+        text=text,
+        timeout=timeout,
+    )
+
+    return result

pyrubix-1.0.0/ulib/randomutil.py

@@ -0,0 +1,31 @@
+import random
+import string
+
+
+def random_int(minimum, maximum):
+    return random.randint(minimum, maximum)
+
+
+def random_float(minimum=0.0, maximum=1.0):
+    return random.uniform(minimum, maximum)
+
+
+def random_choice(values):
+    values = list(values)
+
+    if not values:
+        raise ValueError("values cannot be empty")
+
+    return random.choice(values)
+
+
+def random_string(length):
+    if length < 0:
+        raise ValueError("length cannot be negative")
+
+    alphabet = string.ascii_letters + string.digits
+
+    return "".join(
+        random.choice(alphabet)
+        for _ in range(length)
+    )

pyrubix-1.0.0/ulib/system.py

@@ -0,0 +1,47 @@
+import os
+import platform as _platform
+import shutil
+import sys
+
+try:
+    import resource
+except ImportError:
+    resource = None
+
+
+def platform():
+    return _platform.platform()
+
+
+def python_version():
+    return _platform.python_version()
+
+
+def cpu_count():
+    return os.cpu_count() or 1
+
+
+def memory_usage():
+    if resource is None:
+        return None
+
+    usage = resource.getrusage(resource.RUSAGE_SELF)
+
+    value = usage.ru_maxrss
+
+    if sys.platform == "darwin":
+        return value
+
+    return value * 1024
+
+
+def env(name, default=None):
+    return os.environ.get(name, default)
+
+
+def set_env(name, value):
+    os.environ[str(name)] = str(value)
+
+
+def which(command):
+    return shutil.which(command)

pyrubix-1.0.0/ulib/text.py

@@ -0,0 +1,87 @@
+import re
+
+
+def reverse(text):
+    return text[::-1]
+
+
+def is_palindrome(text):
+    cleaned = "".join(c.lower() for c in text if c.isalnum())
+    return cleaned == cleaned[::-1]
+
+
+def word_count(text):
+    return len(text.split())
+
+
+def char_count(text, include_spaces=False):
+    if include_spaces:
+        return len(text)
+
+    return len("".join(text.split()))
+
+
+def slugify(text):
+    text = text.strip().lower()
+    text = re.sub(r"[^0-9a-z가-힣]+", "-", text)
+    return text.strip("-")
+
+
+def truncate(text, length, suffix="..."):
+    if length < 0:
+        raise ValueError("length cannot be negative")
+
+    if len(text) <= length:
+        return text
+
+    if length <= len(suffix):
+        return suffix[:length]
+
+    return text[:length - len(suffix)] + suffix
+
+
+def camel_case(text):
+    parts = re.split(r"[\s_\-]+", text.strip())
+
+    if not parts:
+        return ""
+
+    return parts[0].lower() + "".join(
+        part[:1].upper() + part[1:].lower()
+        for part in parts[1:]
+        if part
+    )
+
+
+def snake_case(text):
+    text = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", text)
+    text = re.sub(r"[\s\-]+", "_", text)
+    text = re.sub(r"[^0-9a-zA-Z가-힣_]", "", text)
+
+    return text.lower().strip("_")
+
+
+def clean(text):
+    return " ".join(text.split())
+
+
+def remove_spaces(text):
+    return "".join(text.split())
+
+
+def is_email(text):
+    pattern = r"^[^@\s]+@[^@\s]+\.[^@\s]+$"
+    return bool(re.match(pattern, text))
+
+
+def is_url(text):
+    pattern = r"^https?://[^\s]+$"
+    return bool(re.match(pattern, text))
+
+
+def is_number(text):
+    try:
+        float(text)
+        return True
+    except (TypeError, ValueError):
+        return False

pyrubix-1.0.0/ulib/timeutil.py

@@ -0,0 +1,18 @@
+import time
+from datetime import datetime, timezone
+
+
+def now():
+    return datetime.now(timezone.utc)
+
+
+def timestamp():
+    return time.time()
+
+
+def elapsed(start):
+    return time.perf_counter() - start
+
+
+def sleep(seconds):
+    time.sleep(seconds)