svg-ultralight 0.41.0__tar.gz → 0.42.0__tar.gz

{svg_ultralight-0.41.0/src/svg_ultralight.egg-info → svg_ultralight-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: svg-ultralight
-Version: 0.41.0
+Version: 0.42.0
 Summary: a sensible way to create svg files with Python
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT

{svg_ultralight-0.41.0 → svg_ultralight-0.42.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "svg-ultralight"
-version = "0.41.0"
+version = "0.42.0"
 description = "a sensible way to create svg files with Python"
 authors = [{ name = "Shay Hill", email = "shay_public@hotmail.com" }]
 license = { text = "MIT" }
@@ -49,7 +49,7 @@ convention = "pep257"
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version = "0.41.0"
+version = "0.42.0"
 tag_format = "$version"
 version_files = ["pyproject.toml:^version"]
 annotated_tag = true

{svg_ultralight-0.41.0 → svg_ultralight-0.42.0}/src/svg_ultralight/string_conversion.py

@@ -27,10 +27,88 @@ if TYPE_CHECKING:
     )
 
 
-def format_number(num: float | str) -> str:
+_MAYBE_NEG = r"(?:(?P<negative>-?))"
+_MAYBE_INT = r"(?:(?P<integer>\d+?))"
+_MAYBE_FRACTION = r"(?:\.(?P<fraction>\d+))?"
+_MAYBE_EXP = r"(?:[eE](?P<exponent>[+-]?\d+))?"
+
+# Split a float (fp or exponential) into its components. All components are optional.
+FLOAT_PATTERN = re.compile(rf"{_MAYBE_NEG}{_MAYBE_INT}{_MAYBE_FRACTION}{_MAYBE_EXP}")
+
+
+def _split_float_str(num: str | float) -> tuple[str, str, str, int]:
+    """Split a float string into its sign, integer part, fractional part, and exponent.
+
+    :param num_str: A string representing the number (e.g., '1.23e+03').
+    :return: A tuple containing the integer part, fractional part, and exponent.
+    """
+    if float(num) == 0:
+        return "", "", "", 0
+    num_str = str(num)
+    groups = FLOAT_PATTERN.fullmatch(num_str)
+    if not groups:
+        msg = "Invalid number string: {num_str}."
+        raise ValueError(msg.format(num_str=num_str))
+
+    sign = groups["negative"] or ""
+    integer = (groups["integer"] or "").lstrip("0")
+    fraction = (groups["fraction"] or "").rstrip("0")
+    exponent = int(groups["exponent"] or 0)
+    return sign, integer, fraction, exponent
+
+
+def _format_as_fixed_point(num: str | float) -> str:
+    """Format a number in fixed-point notation.
+
+    :param exp_str: A string representing the number in exponential notation
+        (e.g., '1.23e+03') or just a number.
+    :return: A string representing the number in fixed-point notation.
+    """
+    sign, integer, fraction, exponent = _split_float_str(num)
+    if exponent > 0:
+        fraction = fraction.ljust(exponent, "0")
+        integer += fraction[:exponent]
+        fraction = fraction[exponent:]
+    elif exponent < 0:
+        integer = integer.rjust(-exponent, "0")
+        fraction = integer[exponent:] + fraction
+        integer = integer[:exponent]
+
+    fraction = "." + fraction if fraction else ""
+    return f"{sign}{integer}{fraction}" or "0"
+
+
+def _format_as_exponential(num: str | float) -> str:
+    """Convert a number in fixed-point notation (as a string) to exponential notation.
+
+    :param num_str: A string representing the number in fixed-point notation
+        (e.g., '123000') or just a number.
+    :return: A string representing the number in exponential notation.
+    """
+    sign, integer, fraction, exponent = _split_float_str(num)
+    if len(integer) > 1:
+        exponent += len(integer) - 1
+        fraction = (integer[1:] + fraction).rstrip("0")
+        integer = integer[0]
+    elif not integer and fraction:
+        leading_zeroes = len(fraction) - len(fraction.lstrip("0"))
+        exponent -= leading_zeroes + 1
+        integer = fraction[leading_zeroes]
+        fraction = fraction[leading_zeroes + 1 :]
+
+    fraction = "." + fraction if fraction else ""
+    exp_str = f"e{exponent}" if exponent else ""
+    return f"{sign}{integer}{fraction}{exp_str}" or "0"
+
+
+def format_number(num: float | str, precision: float | None = 6) -> str:
     """Format strings at limited precision.
 
     :param num: anything that can print as a float.
+    :param precision: number of digits after the decimal point, default 6. You can
+        also pass None for no precision limit. This may produce some long strings,
+        but will retain as much information as possible when converting between
+        floats and strings.
     :return: str
 
     I've read articles that recommend no more than four digits before and two digits
@@ -38,15 +116,20 @@ def format_number(num: float | str) -> str:
     giving six. Mostly to eliminate exponential notation, but I'm "rstripping" the
     strings to reduce filesize and increase readability
 
-    * reduce fp precision to 6 digits
+    * reduce fp precision to (default) 6 digits
     * remove trailing zeros
     * remove trailing decimal point
+    * remove leading 0 in "0.123"
     * convert "-0" to "0"
+    * use shorter of exponential or fixed-point notation
     """
-    as_str = f"{float(num):0.6f}".rstrip("0").rstrip(".")
-    if as_str == "-0":
-        as_str = "0"
-    return as_str
+    if precision is not None:
+        num = f"{float(num):.{precision}f}"
+    exponential_str = _format_as_exponential(num)
+    fixed_point_str = _format_as_fixed_point(num)
+    if len(exponential_str) < len(fixed_point_str):
+        return exponential_str
+    return fixed_point_str
 
 
 def format_numbers(

{svg_ultralight-0.41.0 → svg_ultralight-0.42.0/src/svg_ultralight.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: svg-ultralight
-Version: 0.41.0
+Version: 0.42.0
 Summary: a sensible way to create svg files with Python
 Author-email: Shay Hill <shay_public@hotmail.com>
 License: MIT

{svg_ultralight-0.41.0 → svg_ultralight-0.42.0}/tests/test_layout.py

@@ -175,14 +175,14 @@ class TestLayout:
         viewbox = (0, 0, 96, 0)
         padded, width_attribs = layout.pad_and_scale(viewbox, "0.25in", "2in")
         assert padded == (-12, -12, 120, 24)
-        assert width_attribs == {"width": "2.5in", "height": "0.5in"}
+        assert width_attribs == {"width": "2.5in", "height": ".5in"}
 
     def test_0_height(self):
         """Test that print width is used to calculate pad"""
         viewbox = (0, 0, 0, 96)
         padded, width_attribs = layout.pad_and_scale(viewbox, "0.25in", None, "2in")
         assert padded == (-12, -12, 24, 120)
-        assert width_attribs == {"width": "0.5in", "height": "2.5in"}
+        assert width_attribs == {"width": ".5in", "height": "2.5in"}
 
     def test_string_padding(self):
         """Test that string padding is converted to float"""
@@ -229,7 +229,7 @@ class TestLayout:
         assert width_attribs == {"width": "12in", "height": "22in"}
 
         padded, width_attribs = layout.pad_and_scale(viewbox, "1in", "100in")
-        assert [format_number(x) for x in padded] == ['-0.1', '-0.1', '10.2', '20.2']
+        assert [format_number(x) for x in padded] == ['-.1', '-.1', '10.2', '20.2']
         assert width_attribs == {"width": "102in", "height": "202in"}
 
     def test_dpu_(self):

{svg_ultralight-0.41.0 → svg_ultralight-0.42.0}/tests/test_new_element.py

@@ -41,7 +41,7 @@ class TestNewElement:
     def test_float(self) -> None:
         """Floats at 0.6f precision."""
         elem = constructors.new_element("text", x=1 / 3)
-        assert etree.tostring(elem) == b'<text x="0.333333"/>'
+        assert etree.tostring(elem) == b'<text x=".333333"/>'
 
 
 class TestNewSubElement:

{svg_ultralight-0.41.0 → svg_ultralight-0.42.0}/tests/test_string_conversion.py

@@ -6,12 +6,54 @@
 
 # pyright: reportPrivateUsage=false
 import random
+import itertools as it
 import string
+from collections.abc import Iterator
+from decimal import Decimal
+
 import pytest
 
 import svg_ultralight.string_conversion as mod
 
 
+_FLOAT_ITERATIONS = 100
+
+def random_floats() -> Iterator[float]:
+    """Yield random float values within(-ish) precision limits.
+
+    Value may exceed the precision limits of the system.
+    """
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.uniform(1e-20, 1e20)
+
+def low_numbers() -> Iterator[float]:
+    """Yield random float values below precision limits.
+
+    Value may exceed the precision limits of the system.
+    """
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.uniform(1e-25, 1e-24)
+
+def high_numbers() -> Iterator[float]:
+    """Yield random float values above precision limits.
+
+    Value may exceed the precision limits of the system.
+    """
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.uniform(1e+24, 1e+25)
+
+
+def random_ints() -> Iterator[int]:
+    """Yield random integer values."""
+    big_int = 2**63 - 1
+    for _ in range(_FLOAT_ITERATIONS):
+        yield random.randint(-big_int, big_int)
+
+def random_numbers() -> Iterator[float]:
+    """Yield random numbers values."""
+    return it.chain(random_floats(), low_numbers(), high_numbers(), random_ints())
+
+
 class TestFormatNuber:
     def test_negative_zero(self):
         """Remove "-" from "-0"."""
@@ -22,6 +64,8 @@ class TestFormatNuber:
         assert mod.format_number(1.0000000001) == "1"
 
 
+
+
 class TestFormatNumbers:
     def test_empty(self):
         """Return empty list."""
@@ -31,10 +75,31 @@ class TestFormatNumbers:
         """Return list of formatted strings."""
         assert mod.format_numbers([1, 2, 3]) == ["1", "2", "3"]
 
+    @pytest.mark.parametrize("num", random_numbers())
+    def test_exp_vs_fp_notation(self, num: float):
+        """Exponential and fp notation have the same value.
+
+        The first assertion is a sanity check.
+        """
+        expect = float(str(num))
+        assert expect == float(Decimal(num))
+        assert expect == float(mod._format_as_fixed_point(str(num)))
+        assert expect == float(mod._format_as_exponential(str(num)))
+
+    @pytest.mark.parametrize("num", random_numbers())
+    def test_exponent_integer_part_is_len_1_or_stripped(self, num: float):
+        """Integer part is one digit."""
+        exponential = mod._format_as_exponential(num)
+        # Result is exactly one digit
+        if "." not in exponential:
+            assert exponential.lstrip("-").isdigit()
+        # Result is nothing before decimal or one non-zero digit before decimal.
+        integer = exponential.split(".")[0].lstrip("-")
+        assert not integer or integer in "123456789"
 
 class TestFormatNumbersInString:
     def test_empty(self):
-        """Return empty string."""
+        """Return empty string.."""
         assert mod.format_numbers_in_string("") == ""
 
     def test_no_numbers(self):
@@ -81,14 +146,14 @@ class TestFormatAttrDict:
 
     def test_datastring(self):
         """Find and format floats in a datastring."""
-        assert mod.format_attr_dict(d="M1.0,0 Q -0,.33333333 1,2z") == {
-            "d": "M1,0 Q 0,0.333333 1,2z"
+        assert mod.format_attr_dict(d="M1.0,0 Q -0,.33333333333 1,2z") == {
+            "d": "M1,0 Q 0,.333333 1,2z"
         }
 
     def test_datastring_with_exponential_number(self):
         """Find and format floats in a datastring."""
         assert mod.format_attr_dict(d="M1.0,1.0e-10 Q -0,.33333333 1,2z") == {
-            "d": "M1,0 Q 0,0.333333 1,2z"
+            "d": "M1,0 Q 0,.333333 1,2z"
         }
 
     def test_format_string(self):