bracex 3.1__tar.gz → 3.2__tar.gz

{bracex-3.1 → bracex-3.2}/.pyspelling.yml

@@ -20,7 +20,7 @@ matrix:
       - alt
       ignores:
       - 'code, pre'
-      - 'a:is(.magiclink-compare, .magiclink-commit, .magiclink-repository)'
+      - 'a:is(.magiclink-compare, .magiclink-commit, .magiclink-repository, .magiclink-mention)'
       - 'span.keys'
       - '.MathJax_Preview, .md-nav__link, .md-footer-custom-text, .md-source__repository, .headerlink, .md-icon'
       - '.md-social__link'

{bracex-3.1 → bracex-3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bracex
-Version: 3.1
+Version: 3.2
 Summary: Bash style brace expander.
 Project-URL: Homepage, https://github.com/facelessuser/bracex
 Author-email: Isaac Muse <Isaac.Muse@gmail.com>
@@ -13,7 +13,6 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -21,7 +20,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 [![Donate via PayPal][donate-image]][donate-link]

{bracex-3.1 → bracex-3.2}/bracex/__init__.py

@@ -396,14 +396,18 @@ class ExpandBrace:
         except StopIteration:
             self.release_expanding(release)
 
+        # Handle empty slot
+        if has_comma and is_empty:
+            result.append(EMPTY)
+
         # Sequence is not valid
         temp2 = iter(['{'])  # type: Iterator[str]
         l = len(result)
-        last_str = False
-        for r in self.flatten(result):
-            is_str = isinstance(r, str)
-            temp2 = self.squash(temp2, [(',' if last_str else '') + r] if is_str else r)
-            last_str = is_str
+        for e, slot in enumerate(result):
+            member = iter([',' if e else ''])  # type: Iterator[str]
+            for r in self.flatten([slot]):
+                member = self.squash(member, [r] if isinstance(r, str) else r)
+            temp2 = self.squash(temp2, member)
         return temp2, self.account(math.prod(counts, start=1))
 
     def get_range(self, i: StringIter) -> tuple[Iterator[str] | None, int]:
@@ -438,19 +442,19 @@ class ExpandBrace:
     def get_int_range(self, m: re.Match[str]) -> tuple[Iterator[str], int]:
         """Get an integer range between start and end and increments of increment."""
 
-        # Capture zero padding extent and capture numerical values without padding and limited to 19 digits.
-        # 64-bit integers are no longer than 19 digits.
+        # Capture zero padding and at most 20 significant digits. The extra digit ensures
+        # values longer than a 64-bit integer are rejected instead of silently truncated.
         spad = m.start(2), m.end(2)
         off = m.start(1)
-        start = m.group(1)[:spad[0] - off] + m.group(1)[spad[1] - off:spad[1] - off + 19]
+        start = m.group(1)[:spad[0] - off] + m.group(1)[spad[1] - off:spad[1] - off + 20]
 
         epad = m.start(4), m.end(4)
         off = m.start(3)
-        end = m.group(3)[:epad[0] - off] + m.group(3)[epad[1] - off :epad[1] - off  + 19]
+        end = m.group(3)[:epad[0] - off] + m.group(3)[epad[1] - off :epad[1] - off  + 20]
 
         ipad = m.start(6), m.end(6)
         off = m.start(5)
-        increment = m.group(5)[0:ipad[0] - off] + m.group(5)[ipad[1] - off:ipad[1] - off + 19] if m.group(5) else '1'
+        increment = m.group(5)[0:ipad[0] - off] + m.group(5)[ipad[1] - off:ipad[1] - off + 20] if m.group(5) else '1'
 
         # Ensure values are within 64 bit range.
         first = int64(start)
@@ -464,12 +468,12 @@ class ExpandBrace:
         if first < last:
             span = abs(last - first + 1)
             ainc = abs(inc)
-            count = math.ceil(span / ainc) if ainc <= span else 1
+            count = (span + ainc - 1) // ainc if ainc <= span else 1
             r = range(first, last + 1, inc)
         else:
             span = abs(first - last + 1)
             ainc = abs(inc)
-            count = math.ceil(span / ainc) if ainc <= span else 1
+            count = (span + ainc - 1) // ainc if ainc <= span else 1
             r = range(first, last - 1, -inc)
 
         return self.format_values(r, padding), count
@@ -484,7 +488,7 @@ class ExpandBrace:
         # 64-bit integers are no longer than 19 digits.
         ipad = m.start(4), m.end(4)
         off = m.start(3)
-        increment = m.group(3)[0:ipad[0] - off] + m.group(3)[ipad[1] - off:ipad[1] - off + 19] if m.group(3) else '1'
+        increment = m.group(3)[0:ipad[0] - off] + m.group(3)[ipad[1] - off:ipad[1] - off + 20] if m.group(3) else '1'
 
         # Ensure values are within 64 bit range.
         inc = max(1, int64(increment))

{bracex-3.1 → bracex-3.2}/bracex/__meta__.py

@@ -193,5 +193,5 @@ def parse_version(ver: str) -> Version:
     return Version(major, minor, micro, release, pre, post, dev)
 
 
-__version_info__ = Version(3, 1, 0, "final")
+__version_info__ = Version(3, 2, 0, "final")
 __version__ = __version_info__._get_canonical()

{bracex-3.1 → bracex-3.2}/docs/src/markdown/about/changelog.md

@@ -1,5 +1,12 @@
 # Changes
 
+## 3.2
+
+-   **NEW**: Drop Python 3.10 support.
+-   **FIX**: Fix some division that could cause 1 off issues with limit checking.
+-   **FIX**: Fix issues related to large range numbers and truncation when compared to Bash (@Rexyysilent).
+-   **FIX**: Fix commas dropped or added when rebuilding invalid brace groups.
+
 ## 3.1
 
 -   **NEW**: Add support for Python 3.15.

{bracex-3.1 → bracex-3.2}/hatch_build.py

@@ -28,7 +28,6 @@ class CustomMetadataHook(MetadataHookInterface):
             'License :: OSI Approved :: MIT License',
             'Operating System :: OS Independent',
             'Programming Language :: Python :: 3',
-            'Programming Language :: Python :: 3.10',
             'Programming Language :: Python :: 3.11',
             'Programming Language :: Python :: 3.12',
             'Programming Language :: Python :: 3.13',

{bracex-3.1 → bracex-3.2}/pyproject.toml

@@ -9,7 +9,7 @@ name = "bracex"
 description = "Bash style brace expander."
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 authors = [
     { name = "Isaac Muse", email = "Isaac.Muse@gmail.com" },
 ]
@@ -127,17 +127,14 @@ dependencies = [
     "pymdown_lexers @ git+https://github.com/facelessuser/pymdown-lexers.git",
     "pyspelling",
     "build",
-    "python-minifier",
-    "beautifulsoup4",
-    "lxml",
-    "html5lib"
+    "python-minifier"
 ]
 
 [[tool.hatch.envs.dev.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+python = ["3.11", "3.12", "3.13", "3.14", "3.15"]
 
 [[tool.hatch.envs.dev-stdlib.matrix]]
-python = ["3.10", "3.11", "3.12", "3.13", "3.14", "3.15"]
+python = ["3.11", "3.12", "3.13", "3.14", "3.15"]
 
 [tool.hatch.envs.dev.scripts]
 types = "mypy"

{bracex-3.1 → bracex-3.2}/tests/brace-cases.txt

@@ -263,3 +263,29 @@ x{{
 {9223372036854775807..9223372036854775808}
 {-9223372036854775808..-9223372036854775805}
 {-9223372036854775809..-9223372036854775807}
+{10000000000000000000..1000000000000000001}
+{1000000000000000000..10000000000000000000}
+{-10000000000000000000..-1000000000000000001}
+{-1000000000000000000..-10000000000000000000}
+{10000000000000000000..10000000000000000001}
+{100000000000000000000..1000000000000000001}
+{0010000000000000000000..1000000000000000001}
+{1000000000000000000..0010000000000000000000}
+{1..3..10000000000000000000}
+{3..1..-10000000000000000000}
+{1..3..0010000000000000000000}
+{a..c..10000000000000000000}
+{c..a..-10000000000000000000}
+{a..c..0010000000000000000000
+# Unclosed groups keep their commas
+{a},{b}
+{x},{y},{z}
+{x},
+a{b},
+{a,
+{a,,
+{,
+{a,{b,c}
+{a,b{c,d}
+{a,b{
+{2{

{bracex-3.1 → bracex-3.2}/tests/brace-results.txt

@@ -1235,4 +1235,31 @@ A{b,{d,e},{f,g}}Z
 [-9223372036854775807]
 [-9223372036854775806]
 [-9223372036854775805]><><><><{-9223372036854775809..-9223372036854775807}
-[{-9223372036854775809..-9223372036854775807}]><><><><
+[{-9223372036854775809..-9223372036854775807}]><><><><{10000000000000000000..1000000000000000001}
+[{10000000000000000000..1000000000000000001}]><><><><{1000000000000000000..10000000000000000000}
+[{1000000000000000000..10000000000000000000}]><><><><{-10000000000000000000..-1000000000000000001}
+[{-10000000000000000000..-1000000000000000001}]><><><><{-1000000000000000000..-10000000000000000000}
+[{-1000000000000000000..-10000000000000000000}]><><><><{10000000000000000000..10000000000000000001}
+[{10000000000000000000..10000000000000000001}]><><><><{100000000000000000000..1000000000000000001}
+[{100000000000000000000..1000000000000000001}]><><><><{0010000000000000000000..1000000000000000001}
+[{0010000000000000000000..1000000000000000001}]><><><><{1000000000000000000..0010000000000000000000}
+[{1000000000000000000..0010000000000000000000}]><><><><{1..3..10000000000000000000}
+[{1..3..10000000000000000000}]><><><><{3..1..-10000000000000000000}
+[{3..1..-10000000000000000000}]><><><><{1..3..0010000000000000000000}
+[{1..3..0010000000000000000000}]><><><><{a..c..10000000000000000000}
+[{a..c..10000000000000000000}]><><><><{c..a..-10000000000000000000}
+[{c..a..-10000000000000000000}]><><><><{a..c..0010000000000000000000
+[{a..c..0010000000000000000000]><><><><{a},{b}
+[{a},{b}]><><><><{x},{y},{z}
+[{x},{y},{z}]><><><><{x},
+[{x},]><><><><a{b},
+[a{b},]><><><><{a,
+[{a,]><><><><{a,,
+[{a,,]><><><><{,
+[{,]><><><><{a,{b,c}
+[{a,b]
+[{a,c]><><><><{a,b{c,d}
+[{a,bc]
+[{a,bd]><><><><{a,b{
+[{a,b{]><><><><{2{
+[{2{]><><><><

{bracex-3.1 → bracex-3.2}/tests/test_brace.py

@@ -379,6 +379,34 @@ class TestExpansionLimit(unittest.TestCase):
         with self.assertRaises(bracex.ExpansionLimitException):
             bracex.expand('{11..1}', limit=10)
 
+    def test_large_integer_range_limit_boundaries(self):
+        """Count large integer ranges exactly at the expansion limit."""
+
+        limit = 1000
+        step = 2**54
+        ranges = (
+            (-(2**63), 1),
+            (2**63 - 1, -1),
+        )
+
+        for start, direction in ranges:
+            with self.subTest(start=start):
+                at_limit_end = start + direction * (limit - 1) * step
+                over_limit_end = start + direction * limit * step
+                at_limit = f'{{{start}..{at_limit_end}..{step}}}'
+                over_limit = f'{{{start}..{over_limit_end}..{step}}}'
+
+                results = bracex.expand(at_limit, limit=limit)
+                self.assertEqual(len(results), limit)
+                self.assertEqual(results[0], str(start))
+                self.assertEqual(results[-1], str(at_limit_end))
+
+                with self.assertRaises(bracex.ExpansionLimitException):
+                    bracex.expand(over_limit, limit=limit)
+
+                self.assertEqual(len(bracex.expand(over_limit, limit=limit + 1)), limit + 1)
+                self.assertEqual(len(bracex.expand(over_limit, limit=0)), limit + 1)
+
     def test_expansion_num_negative_limt_expand(self):
         """Test expansion numeric negative limit with `expand`."""