libdev 0.92__tar.gz → 0.94__tar.gz

{libdev-0.92 → libdev-0.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libdev
-Version: 0.92
+Version: 0.94
 Summary: Set of standard functions for development
 Home-page: https://github.com/chilleco/lib
 Author: Alex Poloz

{libdev-0.92 → libdev-0.94}/libdev/__init__.py

@@ -2,6 +2,6 @@
 Initializing the Python package
 """
 
-__version__ = "0.92"
+__version__ = "0.94"
 
 __all__ = ("__version__",)

libdev-0.94/libdev/num.py

@@ -0,0 +1,437 @@
+"""
+Numbers functionality
+"""
+
+import re
+import math
+from decimal import Decimal, InvalidOperation
+
+
+_SUBSCRIPTS = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
+
+
+def is_float(value: str) -> bool:
+    """Check value for float"""
+
+    try:
+        float(value)
+    except (ValueError, TypeError):
+        return False
+
+    return True
+
+
+def to_num(value) -> bool:
+    """Convert value to int or float"""
+
+    if value is None:
+        return None
+
+    if isinstance(value, str):
+        value = float(value.strip())
+
+    if not value % 1:
+        value = int(value)
+
+    return value
+
+
+def to_int(value) -> int:
+    """Choose only decimal"""
+
+    if not value:
+        return 0
+
+    return int(re.sub(r"\D", "", str(value)))
+
+
+def get_float(value) -> list:
+    """Get a list of floats"""
+
+    if value is None:
+        return []
+
+    numbers = re.findall(r"[-+]?\d*\.\d+|[-+]?\d+", value)
+    return [float(number) for number in numbers]
+
+
+def find_decimals(value):
+    """Get count of decimal"""
+
+    if isinstance(value, str):
+        while value[-1] == "0":
+            value = value[:-1]
+
+    return abs(Decimal(str(value)).as_tuple().exponent)
+
+
+def get_whole(value):
+    """Get whole view of a number"""
+
+    if isinstance(value, int) or (isinstance(value, str) and "." not in value):
+        # NOTE: to remove 0 in the start of the string
+        return str(int(value))
+
+    # NOTE: float for add . to int & support str
+    value = float(value)
+
+    # NOTE: to avoid the exponential form of the number
+    return f"{value:.{find_decimals(value)}f}"
+
+
+def simplify_value(value, decimals=4):
+    """Get the significant part of a number"""
+
+    if value is None:
+        return None
+
+    value = get_whole(value)
+    if "." not in value:
+        value += "."
+
+    whole, fractional = value.split(".")
+
+    if value[0] == "-":
+        sign = "-"
+        whole = whole[1:]
+    else:
+        sign = ""
+
+    if whole != "0":
+        digit = len(whole)
+        value = whole + "." + fractional[: max(0, decimals - digit)]
+
+    else:
+        offset = 0
+        while fractional and fractional[0] == "0":
+            offset += 1
+            fractional = fractional[1:]
+
+        value = "0." + "0" * offset + fractional[:decimals]
+
+    while value[-1] == "0":
+        value = value[:-1]
+
+    if value[-1] == ".":
+        value = value[:-1]
+
+    return sign + value
+
+
+def pretty(
+    value,
+    decimals=None,
+    sign=False,
+    symbol="’",
+    zeros=4,
+    compress=None,
+):
+    """Decorate the number beautifully"""
+
+    if value is None:
+        return None
+
+    # Handle decimals parameter first (takes precedence)
+    if decimals is not None:
+        # Use the original decimals logic for backward compatibility
+        s = to_plain(abs(value))
+        if "." in s:
+            int_part = s.split(".", 1)[0]
+            cur = len(int_part)
+            target_decimals = max(0, decimals - cur)
+            # Apply rounding first
+            rounded_value = round(float(value), target_decimals)
+            # If target_decimals is 0, convert to int for proper formatting
+            if target_decimals == 0:
+                rounded_value = int(rounded_value)
+            # Then use compress_zeros without round parameter
+            data = compress_zeros(rounded_value, zeros=zeros)
+        else:
+            data = compress_zeros(value, zeros=zeros)
+    elif zeros is None and compress is None:
+        # No compression or special formatting requested, use plain representation
+        data = to_plain(value)
+    else:
+        # Use compress_zeros with specified parameters
+        compress_zeros_args = {}
+
+        if zeros is not None:
+            compress_zeros_args["zeros"] = zeros
+
+        if compress is not None:
+            compress_zeros_args["round"] = compress
+
+        data = compress_zeros(value, **compress_zeros_args)
+
+    if data == "0":
+        return "0"
+
+    # Remove trailing zeros after decimal point for cleaner formatting
+    if "." in data and data.rsplit(".", maxsplit=1)[-1] == "0":
+        data = data.split(".", maxsplit=1)[0]
+
+    if symbol:
+        data = add_radix(data, symbol)
+
+    if sign:
+        if data[0] != "-":
+            data = "+" + data
+
+    return data
+
+
+def add_sign(value):
+    """Add sign to a number"""
+
+    if value is None:
+        return None
+
+    sign = ""
+
+    if float(value) > 0:
+        sign = "+"
+    elif value == 0:
+        value = abs(value)
+
+    return f"{sign}{get_whole(value)}"
+
+
+def add_radix(value, symbol="’"):
+    """Add radix to a number"""
+
+    if value is None:
+        return None
+
+    value = str(value)
+
+    if "." in value:
+        integer, fractional = value.split(".")
+    else:
+        integer = value
+        fractional = ""
+
+    if integer[0] == "-":
+        sign = "-"
+        integer = integer[1:]
+    # elif integer[0] == '+':
+    #     sign = '+'
+    #     integer = integer[1:]
+    else:
+        sign = ""
+
+    data = ""
+    ind = 0
+    for i in integer[::-1]:
+        if ind and ind % 3 == 0:
+            data = symbol + data
+        ind += 1
+        data = i + data
+
+    data = sign + data
+    if fractional:
+        data += "." + fractional
+
+    return data
+
+
+def mul(x, y):
+    """Multiply fractions correctly"""
+    if x is None or y is None:
+        return None
+    return float(Decimal(str(x)) * Decimal(str(y)))
+
+
+def div(x, y):
+    """Divide fractions correctly"""
+    if x is None or y is None:
+        return None
+    return float(Decimal(str(x)) / Decimal(str(y)))
+
+
+def add(x, y):
+    """Subtract fractions correctly"""
+    if x is None or y is None:
+        return None
+    return float(Decimal(str(x)) + Decimal(str(y)))
+
+
+def sub(x, y):
+    """Subtract fractions correctly"""
+    if x is None or y is None:
+        return None
+    return float(Decimal(str(x)) - Decimal(str(y)))
+
+
+def to_step(value, step=1, side=False):
+    """Change value step"""
+
+    if value is None:
+        return None
+
+    value = div(value, step)
+    if side:
+        value = math.ceil(value)
+    else:
+        value = math.floor(value)
+    value = mul(value, step)
+
+    if step >= 1:
+        value = int(value)
+
+    return value
+
+
+def to_plain(value) -> str:
+    if value is None:
+        return None
+    try:
+        if isinstance(value, str):
+            d = Decimal(value)
+        elif isinstance(value, float):
+            d = Decimal(str(value))
+        else:
+            d = Decimal(value)
+
+        s = format(d.normalize(), "f")
+
+        if "." in s:
+            s = s.rstrip("0").rstrip(".")
+        if s == "-0":
+            s = "0"
+        return s
+    except (InvalidOperation, ValueError, TypeError):
+        return str(value)
+
+
+def _round_to_decimals(x, decimals):
+    """Helper function to round to specified decimal places"""
+    if decimals <= 0:
+        return float(int(x))
+    return round(float(x), decimals)
+
+
+def compress_zeros(x, zeros=2, round=None) -> str:
+    """
+    0.000012 -> '0.0₄12'
+    1.000045 -> '1.0₄45'
+    round: number of digits after the zero block (rounds).
+    zeros: minimum count of consecutive zeros to compress (default: 2).
+    """
+
+    if x is None:
+        return None
+
+    # Store original string representation for rounding calculations
+    original_str = None
+    if isinstance(x, str):
+        original_str = x.strip()
+        x = original_str
+        # Remove trailing zeros from string
+        if "." in x:
+            x = x.rstrip("0").rstrip(".")
+        # Convert to appropriate numeric type
+        try:
+            if "." in x:
+                x = float(x)
+            else:
+                x = int(x)
+        except ValueError:
+            return str(x)
+
+    # Determine if original was float or int to preserve format
+    is_float_type = isinstance(x, float) or (isinstance(x, str) and "." in str(x))
+
+    # Handle rounding if specified
+    if round is not None:
+        # For rounding, use original string if available, otherwise convert to plain string
+        if original_str and "." in original_str:
+            s = original_str.lstrip("-")
+        else:
+            # Use to_plain to avoid scientific notation
+            s = to_plain(abs(x))
+
+        if "." in s:
+            int_part, frac_part = s.split(".")
+            # Count leading zeros in fractional part
+            leading_zeros = 0
+            for c in frac_part:
+                if c == "0":
+                    leading_zeros += 1
+                else:
+                    break
+
+            # Count trailing zeros in fractional part
+            trailing_zeros = 0
+            for c in reversed(frac_part):
+                if c == "0":
+                    trailing_zeros += 1
+                else:
+                    break
+
+            # Apply rounding logic
+            if leading_zeros > 0:
+                # If there are leading zeros, round after them (regardless of compression)
+                total_decimals = leading_zeros + round
+                x = _round_to_decimals(x, total_decimals)
+            else:
+                # No leading zeros, apply normal rounding
+                x = _round_to_decimals(x, round)
+
+    # Convert to string representation
+    if isinstance(x, int) and not is_float_type:
+        s = str(x)
+    else:
+        # For floats, use format that preserves trailing decimals when needed
+        if x == int(x) and is_float_type:
+            s = f"{int(x)}.0"
+        else:
+            s = str(float(x))
+            # Remove scientific notation if present
+            if "e" in s.lower():
+                s = f"{float(x):.15f}".rstrip("0")
+                if s.endswith("."):
+                    s += "0"
+
+    # Handle negative sign
+    negative = s.startswith("-")
+    if negative:
+        s = s[1:]
+
+    # Process compression
+    if "." not in s:
+        result = s
+    else:
+        int_part, frac_part = s.split(".")
+
+        # Compress leading zeros in fractional part
+        leading_zeros = 0
+        for c in frac_part:
+            if c == "0":
+                leading_zeros += 1
+            else:
+                break
+
+        # Compress trailing zeros in fractional part
+        trailing_zeros = 0
+        for c in reversed(frac_part):
+            if c == "0":
+                trailing_zeros += 1
+            else:
+                break
+
+        # Apply compression
+        if leading_zeros >= zeros:
+            # Compress leading zeros
+            remaining_frac = frac_part[leading_zeros:]
+            result = f"{int_part}.0{str(leading_zeros).translate(_SUBSCRIPTS)}{remaining_frac}"
+        elif trailing_zeros >= zeros and leading_zeros == 0:
+            # Compress trailing zeros (but not if there are leading zeros)
+            remaining_frac = frac_part[:-trailing_zeros]
+            if remaining_frac:
+                result = f"{int_part}.{remaining_frac}0{str(trailing_zeros).translate(_SUBSCRIPTS)}"
+            else:
+                result = f"{int_part}.0{str(trailing_zeros).translate(_SUBSCRIPTS)}"
+        else:
+            result = s
+
+    return f"-{result}" if negative else result

{libdev-0.92 → libdev-0.94}/libdev/time.py

@@ -300,6 +300,27 @@ def get_month_start(timestamp=None, tz=0):
     return int(start_month.timestamp())
 
 
+def get_week_start(timestamp=None, tz=0):
+    """
+    Get the start of the week (midnight on Monday) for a given timestamp in a specified timezone.
+
+    Args:
+        timestamp (float): The original timestamp (in seconds since epoch). Defaults to the current time if None.
+        tz (int): The timezone offset in hours (e.g., 3 for UTC+3).
+
+    Returns:
+        float: The timestamp for the start of the week (Monday at midnight) in the specified timezone.
+    """
+    if timestamp is None:
+        timestamp = time.time()
+    dt_local = datetime.datetime.fromtimestamp(timestamp, tz=to_tz(tz))
+    # Calculate days to subtract to get to Monday (weekday() returns 0 for Monday, 6 for Sunday)
+    days_since_monday = dt_local.weekday()
+    start_week = dt_local - datetime.timedelta(days=days_since_monday)
+    start_week = start_week.replace(hour=0, minute=0, second=0, microsecond=0)
+    return int(start_week.timestamp())
+
+
 def get_next_day(timestamp=None, tz=0):
     """
     Get the start of the next day (midnight) for a given timestamp in a specified timezone.

{libdev-0.92 → libdev-0.94}/libdev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libdev
-Version: 0.92
+Version: 0.94
 Summary: Set of standard functions for development
 Home-page: https://github.com/chilleco/lib
 Author: Alex Poloz

{libdev-0.92 → libdev-0.94}/tests/test_num.py

@@ -11,6 +11,8 @@ from libdev.num import (
     to_step,
     add,
     pretty,
+    to_plain,
+    compress_zeros,
 )
 
 
@@ -155,3 +157,93 @@ def test_pretty():
     assert pretty(123.456, 1) == "123"
     assert pretty(123.456, 1, True) == "+123"
     assert pretty(12345.6, 3, True) == "+12’346"
+    assert pretty(-0.000000235235, zeros=None, compress=None) == "-0.000000235235"
+    assert pretty(-0.000000235235, zeros=4, compress=2) == "-0.0₆24"
+
+
+def test_to_plain():
+    assert to_plain(None) == None
+    assert to_plain(0) == "0"
+    # assert to_plain(0.0) == "0.0"
+    # assert to_plain(1.0) == "1.0"
+    assert to_plain(1.1) == "1.1"
+    assert to_plain(0.000000235235) == "0.000000235235"
+    assert to_plain(-0.000000235235) == "-0.000000235235"
+    assert to_plain("0.000000235235") == "0.000000235235"
+    assert to_plain(2.35235e-07) == "0.000000235235"
+    assert to_plain("1e-12") == "0.000000000001"
+    assert to_plain("123.4500") == "123.45"
+
+
+def test_pretty_with_compression():
+    # Test pretty function with compression parameters
+
+    # Test zeros parameter (minimum zeros to compress)
+    assert pretty(0.00012, zeros=2) == "0.0₃12"  # Default behavior, compress >=2 zeros
+    assert pretty(0.01, zeros=1) == "0.0₁1"  # Compress single zero with zeros=1
+    assert pretty(0.01, zeros=3) == "0.01"  # Don't compress with zeros=3 (only 1 zero)
+    assert pretty(0.0001, zeros=3) == "0.0₃1"  # Compress with zeros=3 (3 zeros)
+
+    # Test compress parameter (round after zero block)
+    assert (
+        pretty(0.00012345, zeros=2, compress=2) == "0.0₃12"
+    )  # Round to 2 digits after zeros
+    assert (
+        pretty(0.00012345, zeros=4, compress=4) == "0.0001234"
+    )  # No compression (3 < 4 zeros), 4 digits after 3 zeros
+    assert pretty(0.00012345, zeros=4, compress=8) == "0.00012345"
+    assert (
+        pretty(0.00012345, zeros=2, compress=3) == "0.0₃123"
+    )  # Round to 3 digits after zeros
+    assert (
+        pretty(-0.0010959999999999997522, compress=3) == "-0.0011"
+    )  # Negative with rounding
+
+    # Test both parameters together
+    assert (
+        pretty("0.0000012345", zeros=4, compress=2) == "0.0₅12"
+    )  # 5 zeros, round to 2 digits
+    assert (
+        pretty("0.00012345", zeros=4, compress=2) == "0.00012"
+    )  # Only 3 zeros, no compression, 2 digits after 3 zeros
+
+    # Test that other pretty parameters still work with compression
+    assert pretty(0.00012, zeros=2, sign=True) == "+0.0₃12"  # With sign
+    assert pretty(12000.00012, zeros=2, symbol="'") == "12'000.0₃12"  # With radix
+    assert (
+        pretty(-0.00012, zeros=2, sign=True, symbol="'") == "-0.0₃12"
+    )  # Negative with sign and radix
+
+    # Test edge cases
+    assert pretty(0, zeros=1) == "0"  # Zero value
+    assert pretty(None, zeros=2) == None  # None value
+    assert (
+        pretty(1.0, zeros=2) == "1"
+    )  # No fractional zeros to compress, trailing zero removed for clean formatting
+
+
+def test_compress_zeros():
+    assert compress_zeros(None) == None
+    assert compress_zeros(0) == "0"
+    assert compress_zeros(0.0) == "0.0"
+    assert compress_zeros(1) == "1"
+    assert compress_zeros(1.0) == "1.0"
+    assert compress_zeros(1.0, round=0) == "1.0"
+    assert compress_zeros(0.00012) == "0.0₃12"
+    assert compress_zeros(0.00012, round=2) == "0.0₃12"
+    assert compress_zeros(0.0123) == "0.0123"
+    assert compress_zeros(0.0123456, round=3) == "0.0123"
+    assert compress_zeros(1.000045) == "1.0₄45"
+    assert compress_zeros(0.0010859999999999997522, round=3) == "0.0₂109"
+    assert compress_zeros(-0.0010959999999999997522, round=3) == "-0.0₂11"
+    assert compress_zeros("-0.012300") == "-0.0123"
+    assert compress_zeros(0.01, zeros=1) == "0.0₁1"
+    assert compress_zeros(0.001, zeros=1) == "0.0₂1"
+    assert compress_zeros("1.10", zeros=1) == "1.1"
+    assert compress_zeros(0.01, zeros=3) == "0.01"
+    assert compress_zeros(0.001, zeros=3) == "0.001"
+    assert compress_zeros(0.0001, zeros=3) == "0.0₃1"
+    assert compress_zeros(0.00001, zeros=3) == "0.0₄1"
+    assert compress_zeros(0.0000012, zeros=1) == "0.0₅12"
+    assert compress_zeros(0.0000012, zeros=5) == "0.0₅12"
+    assert compress_zeros(0.0000012, zeros=6) == "0.0000012"

libdev-0.92/libdev/num.py

@@ -1,244 +0,0 @@
-"""
-Numbers functionality
-"""
-
-import re
-import math
-from decimal import Decimal
-
-
-def is_float(value: str) -> bool:
-    """Check value for float"""
-
-    try:
-        float(value)
-    except (ValueError, TypeError):
-        return False
-
-    return True
-
-
-def to_num(value) -> bool:
-    """Convert value to int or float"""
-
-    if value is None:
-        return None
-
-    if isinstance(value, str):
-        value = float(value.strip())
-
-    if not value % 1:
-        value = int(value)
-
-    return value
-
-
-def to_int(value) -> int:
-    """Choose only decimal"""
-
-    if not value:
-        return 0
-
-    return int(re.sub(r"\D", "", str(value)))
-
-
-def get_float(value) -> list:
-    """Get a list of floats"""
-
-    if value is None:
-        return []
-
-    numbers = re.findall(r"[-+]?\d*\.\d+|[-+]?\d+", value)
-    return [float(number) for number in numbers]
-
-
-def find_decimals(value):
-    """Get count of decimal"""
-
-    if isinstance(value, str):
-        while value[-1] == "0":
-            value = value[:-1]
-
-    return abs(Decimal(str(value)).as_tuple().exponent)
-
-
-def get_whole(value):
-    """Get whole view of a number"""
-
-    if isinstance(value, int) or (isinstance(value, str) and "." not in value):
-        # NOTE: to remove 0 in the start of the string
-        return str(int(value))
-
-    # NOTE: float for add . to int & support str
-    value = float(value)
-
-    # NOTE: to avoid the exponential form of the number
-    return f"{value:.{find_decimals(value)}f}"
-
-
-def simplify_value(value, decimals=4):
-    """Get the significant part of a number"""
-
-    if value is None:
-        return None
-
-    value = get_whole(value)
-    if "." not in value:
-        value += "."
-
-    whole, fractional = value.split(".")
-
-    if value[0] == "-":
-        sign = "-"
-        whole = whole[1:]
-    else:
-        sign = ""
-
-    if whole != "0":
-        digit = len(whole)
-        value = whole + "." + fractional[: max(0, decimals - digit)]
-
-    else:
-        offset = 0
-        while fractional and fractional[0] == "0":
-            offset += 1
-            fractional = fractional[1:]
-
-        value = "0." + "0" * offset + fractional[:decimals]
-
-    while value[-1] == "0":
-        value = value[:-1]
-
-    if value[-1] == ".":
-        value = value[:-1]
-
-    return sign + value
-
-
-def pretty(value, decimals=None, sign=False, symbol="’"):
-    """Decorate the number beautifully"""
-
-    if value is None:
-        return None
-
-    data = str(float(value))
-
-    if decimals is not None:
-        cur = len(data.split(".", maxsplit=1)[0])
-        data = str(round(value, max(0, decimals - cur)))
-
-    if data.rsplit(".", maxsplit=1)[-1] == "0":
-        data = data.split(".", maxsplit=1)[0]
-
-    if data == "0":
-        return "0"
-
-    if symbol:
-        data = add_radix(data, symbol)
-
-    if sign:
-        if data[0] != "-":
-            data = "+" + data
-
-    return data
-
-
-def add_sign(value):
-    """Add sign to a number"""
-
-    if value is None:
-        return None
-
-    sign = ""
-
-    if float(value) > 0:
-        sign = "+"
-    elif value == 0:
-        value = abs(value)
-
-    return f"{sign}{get_whole(value)}"
-
-
-def add_radix(value, symbol="’"):
-    """Add radix to a number"""
-
-    if value is None:
-        return None
-
-    value = str(value)
-
-    if "." in value:
-        integer, fractional = value.split(".")
-    else:
-        integer = value
-        fractional = ""
-
-    if integer[0] == "-":
-        sign = "-"
-        integer = integer[1:]
-    # elif integer[0] == '+':
-    #     sign = '+'
-    #     integer = integer[1:]
-    else:
-        sign = ""
-
-    data = ""
-    ind = 0
-    for i in integer[::-1]:
-        if ind and ind % 3 == 0:
-            data = symbol + data
-        ind += 1
-        data = i + data
-
-    data = sign + data
-    if fractional:
-        data += "." + fractional
-
-    return data
-
-
-def mul(x, y):
-    """Multiply fractions correctly"""
-    if x is None or y is None:
-        return None
-    return float(Decimal(str(x)) * Decimal(str(y)))
-
-
-def div(x, y):
-    """Divide fractions correctly"""
-    if x is None or y is None:
-        return None
-    return float(Decimal(str(x)) / Decimal(str(y)))
-
-
-def add(x, y):
-    """Subtract fractions correctly"""
-    if x is None or y is None:
-        return None
-    return float(Decimal(str(x)) + Decimal(str(y)))
-
-
-def sub(x, y):
-    """Subtract fractions correctly"""
-    if x is None or y is None:
-        return None
-    return float(Decimal(str(x)) - Decimal(str(y)))
-
-
-def to_step(value, step=1, side=False):
-    """Change value step"""
-
-    if value is None:
-        return None
-
-    value = div(value, step)
-    if side:
-        value = math.ceil(value)
-    else:
-        value = math.floor(value)
-    value = mul(value, step)
-
-    if step >= 1:
-        value = int(value)
-
-    return value