bracex 3.2__tar.gz → 3.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bracex
-Version: 3.2
+Version: 3.2.1
 Summary: Bash style brace expander.
 Project-URL: Homepage, https://github.com/facelessuser/bracex
 Author-email: Isaac Muse <Isaac.Muse@gmail.com>

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

@@ -33,8 +33,11 @@ __version_info__ = __meta__.__version_info__
 _alpha = [chr(x) if x != 0x5c else '' for x in range(ord('A'), ord('z') + 1)]
 _nalpha = list(reversed(_alpha))
 
-RE_INT_ITER = re.compile(r'(-?((?:0(?=\d))*)\d+)\.{2}(-?((?:0(?=\d))*)\d+)(?:\.{2}-?(((?:0(?=\d))*)\d+))?(?=\})')
-RE_CHR_ITER = re.compile(r'([A-Za-z])\.{2}([A-Za-z])(?:\.{2}-?(((?:0(?=\d))*)\d+))?(?=\})')
+RE_INT_ITER = re.compile(
+    r'([-+]?((?:0(?=\d))*)\d+)\.{2}([-+]?((?:0(?=\d))*)\d+)(?:\.{2}[-+]?(((?:0(?=\d))*)\d+))?(?=\})', re.ASCII
+)
+RE_CHR_ITER = re.compile(r'([A-Za-z])\.{2}([A-Za-z])(?:\.{2}[-+]?(((?:0(?=\d))*)\d+))?(?=\})', re.ASCII)
+RE_SEQ_SEP = re.compile(r'\.(?!\})')
 
 DEFAULT_LIMIT = 1000
 
@@ -241,7 +244,7 @@ class ExpandBrace:
         i: StringIter,
         depth: int,
         ignore_end: bool = False
-    ) -> tuple[list[str | Iterator[str]], int]:
+    ) -> tuple[list[str | Iterator[str]], int, bool]:
         """
         Get a string literal.
 
@@ -250,9 +253,12 @@ class ExpandBrace:
         """
 
         result = []  # type: list[str | Iterator[str]]
+        word_start = 0
         is_dollar = False
+        dollar_depth = 0
         count = 1
         literal = ''
+        has_seq = False
 
         try:
             while c:
@@ -266,7 +272,11 @@ class ExpandBrace:
                 elif c == '\\':
                     literal += self.get_escape(c, i)
 
-                elif not ignore_brace and c == '{':
+                elif (ignore_brace and c == '{') or (dollar_depth and c == '}'):
+                    literal += c
+                    dollar_depth += 1 if c == '{' else -1
+
+                elif c == '{':
 
                     if literal:
                         result.append(literal)
@@ -274,7 +284,10 @@ class ExpandBrace:
 
                     # Try and get the group
                     try:
-                        seq, scount = self.get_sequence(next(i), i, depth + 1)
+                        seq, scount, expanded = self.get_sequence(next(i), i, depth + 1, word_start)
+                        if expanded:
+                            # Bash expands each postamble as a new word.
+                            word_start = i.index
                         count *= scount
                         result.append(seq)
                     except StopIteration:
@@ -283,7 +296,7 @@ class ExpandBrace:
                         literal += c
                         raise
 
-                elif self.is_expanding() and (c == ',' or (c == '}' and not ignore_end)):
+                elif self.is_expanding() and not dollar_depth and (c == ',' or (c == '}' and not ignore_end)):
                     # We are Expanding within a group and found a group delimiter
                     # Return what we gathered before the group delimiters.
 
@@ -294,6 +307,14 @@ class ExpandBrace:
 
                     i.rewind(1)
                     break
+
+                elif not dollar_depth and c == '.' and i.match(RE_SEQ_SEP):
+                    # Bash counts `..` like a comma when looking for the `}` that ends a top level group,
+                    # unless `}` follows it, so the next `}` can end the group.
+                    ignore_end = False
+                    has_seq = True
+                    literal += '..'
+
                 else:
                     literal += c
 
@@ -303,9 +324,9 @@ class ExpandBrace:
             if literal:
                 result.append(literal)
 
-        return result, self.account(count)
+        return result, self.account(count), has_seq
 
-    def get_sequence(self, c: str, i: StringIter, depth: int) -> tuple[Iterator[str], int]:
+    def get_sequence(self, c: str, i: StringIter, depth: int, word_start: int) -> tuple[Iterator[str], int, bool]:
         """
         Get the sequence.
 
@@ -316,6 +337,7 @@ class ExpandBrace:
         result = []  # type: list[str | Iterator[str] | Iterable[str | Iterator[str]]]
         release = self.set_expanding()
         has_comma = False  # Used to indicate validity of group (`{1..2}` are an exception).
+        has_seq = False  # Used to indicate a top level `..` that lets the next `}` end the group.
         is_empty = True  # Tracks whether the current slot is empty `{slot,slot,slot}`.
         counts = []
 
@@ -325,15 +347,15 @@ class ExpandBrace:
         i.advance(1)
         if item is not None:
             self.release_expanding(release)
-            return item, self.account(count)
+            return item, self.account(count), True
 
         try:
             while True:
                 # Bash has some special top level logic. if `}` follows `{` but hasn't matched
-                # a group yet, keep going except when the first 2 bytes are `{}` which gets
-                # completely ignored.
-                keep_looking = depth == 1 and not has_comma
-                if (c == '}' and (not keep_looking or i.index == 2)):
+                # a group yet, keep going except when the first 2 bytes of the current
+                # postamble are `{}` which gets completely ignored.
+                keep_looking = depth == 1 and not has_comma and not has_seq
+                if (c == '}' and (not keep_looking or i.index == word_start + 2)):
                     self.release_expanding(release)
 
                     # Handle empty slot
@@ -349,7 +371,7 @@ class ExpandBrace:
                         for r in self.flatten(result):
                             temp = self.squash(temp, [r] if isinstance(r, str) else r)
                         temp = self.squash(temp, ['}'])
-                        return temp, self.account(math.prod(counts, start=1))
+                        return temp, self.account(math.prod(counts, start=1)), False
 
                     # Format return for a sequence
                     fin = iter([])  # type: Iterator[str]
@@ -369,7 +391,7 @@ class ExpandBrace:
                             start = e + 1
                     if start < l:
                         fin = self.chain(fin, result[start:])
-                    return fin, self.account(sum(counts))
+                    return fin, self.account(sum(counts)), True
 
                 elif c == ',':
                     # Must be the first element in the list.
@@ -382,7 +404,7 @@ class ExpandBrace:
 
                 else:
                     # Lower level: Try to find group, but give up if cannot acquire.
-                    value, lcount = self.get_literals(c, i, depth, keep_looking)
+                    value, lcount, has_seq = self.get_literals(c, i, depth, keep_looking)
                     counts.append(lcount)
                     if value is not None:
                         if len(value) > 1:
@@ -408,7 +430,7 @@ class ExpandBrace:
             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))
+        return temp2, self.account(math.prod(counts, start=1)), False
 
     def get_range(self, i: StringIter) -> tuple[Iterator[str] | None, int]:
         """
@@ -461,9 +483,15 @@ class ExpandBrace:
         last = int64(end)
         inc = max(1, int64(increment))
 
+        # Bash's zero-padding rule: padding is only enabled when an operand, as written,
+        # starts with `0` (or `-0`). A unary `+` sign never enables padding, but once
+        # padding is enabled by either operand, the full written width of both operands
+        # (signs included) is honored.
+        arm = bool((spad[1] - spad[0]) and not start.startswith('+'))
+        arm = arm or bool((epad[1] - epad[0]) and not end.startswith('+'))
         spad_len = spad[1] - spad[0]
         epad_len = epad[1] - epad[0]
-        padding = max(spad_len + len(start), epad_len + len(end)) if spad_len or epad_len else 0
+        padding = max(spad_len + len(start), epad_len + len(end)) if arm else 0
 
         if first < last:
             span = abs(last - first + 1)
@@ -513,7 +541,7 @@ class ExpandBrace:
         """Expand the string."""
 
         i = StringIter(string)
-        values, _ = self.get_literals(next(i), i, 0)
+        values, _, _ = self.get_literals(next(i), i, 0)
 
         # Squash the nested list by calculating the combinations
         results = iter([EMPTY])  # type: Iterator[str]

{bracex-3.2 → bracex-3.2.1}/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, 2, 0, "final")
+__version_info__ = Version(3, 2, 1, "final")
 __version__ = __version_info__._get_canonical()

bracex-3.2.1/docs/src/dictionary/en-custom.txt

@@ -0,0 +1,45 @@
+API
+Accessors
+Backport
+Bracex
+Changelog
+Formatter
+GitHub
+Gitter
+KiB
+MERCHANTABILITY
+MkDocs
+NONINFRINGEMENT
+NUL
+Preprocess
+PyPI
+Setuptools
+TODO
+Tox
+Twemoji
+Virtualenv
+Willmer
+Zensical
+accessor
+backend
+deprecations
+expander
+formatter
+globbing
+incrementer
+iterables
+linter
+postamble
+pre
+prerelease
+prereleases
+pytest
+regex
+santhreal
+stdout
+sublicense
+tuple
+uncatchable
+validator
+wordlist
+unary

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

@@ -1,5 +1,14 @@
 # Changes
 
+## 3.2.1
+
+-   **FIX**: Keep numeric sequences with non-ASCII digits literal, matching Bash.
+-   **FIX**: Preserve an initial empty brace group after a valid expansion.
+-   **FIX**: Fix `${...}` inside a brace group ending the group early.
+-   **FIX**: Fix an invalid sequence such as `{1..a}` being split at a later comma instead of being kept as text.
+-   **FIX**: Fix numeric and character sequences with unary `+` signs (`{+1..3}`, `{1..+3..2}`, `{a..z..+2}`)
+    being left as literal text instead of expanded like Bash, including Bash's zero-padding rule for `+` operands.
+
 ## 3.2
 
 -   **NEW**: Drop Python 3.10 support.

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

@@ -40,11 +40,10 @@ include = [
     "/docs/src/markdown/**/*.md",
     "/docs/src/markdown/**/*.gif",
     "/docs/src/markdown/**/*.png",
-    "/docs/src/markdown/dictionary/*.txt",
+    "/docs/src/dictionary/*.txt",
     "/docs/theme/**/*.css",
     "/docs/theme/**/*.js",
     "/docs/theme/**/*.html",
-    "/requirements/*.txt",
     "/bracex/**/*.py",
     "/bracex/py.typed",
     "/tests/**/*.py",
@@ -53,7 +52,7 @@ include = [
     "/tools/**/*.py",
     "/.pyspelling.yml",
     "/.coveragerc",
-    "/mkdocs.yml"
+    "/zensical.yml"
 ]
 
 [tool.mypy]

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

@@ -289,3 +289,51 @@ a{b},
 {a,b{c,d}
 {a,b{
 {2{
+# A top level `..` that is not followed by `}` lets the next `}` end the group
+{1..a},b}
+{a...},c}
+a{1..a},b}c
+{1..a},{b,c}}
+{1..},b}
+# An initial empty group is literal in the postamble after a valid expansion
+{a,b}{},c}
+{1..2}{},c}
+prefix{a,b}{},tail}
+{a,b}x{},c}
+{a,b}{}{},c}
+{word}{},c}
+{a{b,c}}{},d}
+{+1..3}
+{+1..+3}
+{3..+1}
+{+1..+3..2}
+{1..+3..2}
+{+1..+3..+2}
+{+3..1..+2}
+{+05..8}
+{+005..8}
+{05..+8}
+{+5..+08}
+{+05..+05}
+{+05..08}
+{+10..08}
+{-05..+2}
+{+5..05}
+{+5..08}
+{08..+5}
+{+003..1}
+{a..z..+2}
+a{+1..2}b
+{a,{+1..2},b}
+{+9223372036854775806..+9223372036854775807}
+{١..٣}
+{１..３}
+{1..٣}
+{١..3}
+{1..3..٢}
+{a..e..٢}
+{0١..03}
+x{١..٣}y
+{a,{١..٣},b}
+{+١..+٣}
+{-١..٣}

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

@@ -1262,4 +1262,125 @@ A{b,{d,e},{f,g}}Z
 [{a,bc]
 [{a,bd]><><><><{a,b{
 [{a,b{]><><><><{2{
-[{2{]><><><><
+[{2{]><><><><{1..a},b}
+[{1..a},b}]><><><><{a...},c}
+[{a...},c}]><><><><a{1..a},b}c
+[a{1..a},b}c]><><><><{1..a},{b,c}}
+[{1..a},b}]
+[{1..a},c}]><><><><{1..},b}
+[1..}]
+[b]><><><><{a,b}{},c}
+[a{},c}]
+[b{},c}]><><><><{1..2}{},c}
+[1{},c}]
+[2{},c}]><><><><prefix{a,b}{},tail}
+[prefixa{},tail}]
+[prefixb{},tail}]><><><><{a,b}x{},c}
+[ax}]
+[axc]
+[bx}]
+[bxc]><><><><{a,b}{}{},c}
+[a{}}]
+[a{}c]
+[b{}}]
+[b{}c]><><><><{word}{},c}
+[word}{}]
+[c]><><><><{a{b,c}}{},d}
+[ab}{}]
+[ac}{}]
+[d]><><><><{+1..3}
+[1]
+[2]
+[3]><><><><{+1..+3}
+[1]
+[2]
+[3]><><><><{3..+1}
+[3]
+[2]
+[1]><><><><{+1..+3..2}
+[1]
+[3]><><><><{1..+3..2}
+[1]
+[3]><><><><{+1..+3..+2}
+[1]
+[3]><><><><{+3..1..+2}
+[3]
+[1]><><><><{+05..8}
+[5]
+[6]
+[7]
+[8]><><><><{+005..8}
+[5]
+[6]
+[7]
+[8]><><><><{05..+8}
+[05]
+[06]
+[07]
+[08]><><><><{+5..+08}
+[5]
+[6]
+[7]
+[8]><><><><{+05..+05}
+[5]><><><><{+05..08}
+[005]
+[006]
+[007]
+[008]><><><><{+10..08}
+[010]
+[009]
+[008]><><><><{-05..+2}
+[-05]
+[-04]
+[-03]
+[-02]
+[-01]
+[000]
+[001]
+[002]><><><><{+5..05}
+[05]><><><><{+5..08}
+[05]
+[06]
+[07]
+[08]><><><><{08..+5}
+[08]
+[07]
+[06]
+[05]><><><><{+003..1}
+[3]
+[2]
+[1]><><><><{a..z..+2}
+[a]
+[c]
+[e]
+[g]
+[i]
+[k]
+[m]
+[o]
+[q]
+[s]
+[u]
+[w]
+[y]><><><><a{+1..2}b
+[a1b]
+[a2b]><><><><{a,{+1..2},b}
+[a]
+[1]
+[2]
+[b]><><><><{+9223372036854775806..+9223372036854775807}
+[9223372036854775806]
+[9223372036854775807]><><><><{١..٣}
+[{١..٣}]><><><><{１..３}
+[{１..３}]><><><><{1..٣}
+[{1..٣}]><><><><{١..3}
+[{١..3}]><><><><{1..3..٢}
+[{1..3..٢}]><><><><{a..e..٢}
+[{a..e..٢}]><><><><{0١..03}
+[{0١..03}]><><><><x{١..٣}y
+[x{١..٣}y]><><><><{a,{١..٣},b}
+[a]
+[{١..٣}]
+[b]><><><><{+١..+٣}
+[{+١..+٣}]><><><><{-١..٣}
+[{-١..٣}]><><><><

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

@@ -50,7 +50,18 @@ class TestBraces:
     dollar_cases = [
         ['${1..3}', ['${1..3}']],
         ['${a,b}${c,d}', ['${a,b}${c,d}']],
-        ['x${a,b}x${c,d}x', ['x${a,b}x${c,d}x']]
+        ['x${a,b}x${c,d}x', ['x${a,b}x${c,d}x']],
+        ['{a,${b}}', ['a', '${b}']],
+        ['{${a,b},c}', ['${a,b}', 'c']],
+        ['{a,${b{c}d}e}', ['a', '${b{c}d}e']],
+        [r'{a,${b\}c}}', ['a', '${b}c}']],
+        ['${x{1..2}}', ['${x1}', '${x2}']],
+        ['${x{a,b}}', ['${xa}', '${xb}']],
+        ['{a,${x{1..2}}}', ['a', '${x1}', '${x2}']],
+        ['{a,${x{c,d}}}', ['a', '${xc}', '${xd}']],
+        ['x${y{a,b}}z', ['x${ya}z', 'x${yb}z']],
+        ['q{b}${b,c}z', ['q{b}${b,c}z']],
+        ['{a${x:-..b}},c}', ['a${x:-..b}}', 'c']]
     ]
 
     empty_cases = [

bracex-3.2.1/zensical.yml

@@ -0,0 +1,164 @@
+site_name: Bracex
+site_url: https://facelessuser.github.io/bracex
+repo_url: https://github.com/facelessuser/bracex
+edit_uri: tree/master/docs/src/markdown
+site_description: Python spell checker.
+copyright: |
+  Copyright &copy; 2018 - 2026 <a href="https://github.com/facelessuser"  target="_blank" rel="noopener">Isaac Muse</a>
+
+docs_dir: docs/src/markdown
+theme:
+  name: zensical_pymdownx
+  custom_dir: docs/theme
+  features:
+    - announce.dismiss
+    - navigation.tabs
+    - navigation.top
+    - navigation.instant
+    - navigation.indexes
+    - navigation.path
+    - navigation.footer
+    - toc.follow
+    - content.tabs.link
+    - search.share
+    - search.highlight
+    - search.suggest
+    - content.code.copy
+    - content.tabs.link
+    - content.code.annotations
+
+nav:
+  - Home:
+    - Usage: index.md
+  - About:
+    - Contributing &amp; Support: about/contributing.md
+    - Development: about/development.md
+    - Changelog: about/changelog.md
+    - License: about/license.md
+
+markdown_extensions:
+  - toc:
+      slugify: !!python/object/apply:pymdownx.slugs.slugify {kwds: {case: lower}}
+      permalink: ""
+  - smarty:
+      smart_quotes: false
+  - pymdownx.betterem:
+  - attr_list:
+  - tables:
+  - abbr:
+  - footnotes:
+  - md_in_html:
+  - pymdownx.superfences:
+      preserve_tabs: true
+      relaxed_headers: true
+      custom_fences:
+        - name: py
+          class: 'highlight'
+          format: !!python/object/apply:tools.pycon.py_command_formatter
+            kwds:
+              init: |
+                import bracex
+          validator: !!python/name:tools.pycon.py_command_validator
+          reset: !!python/name:tools.pycon.py_command_reset
+        - name: python
+          class: 'highlight'
+          format: !!python/object/apply:tools.pycon.py_command_formatter
+            kwds:
+              init: |
+                import bracex
+          validator: !!python/name:tools.pycon.py_command_validator
+          reset: !!python/name:tools.pycon.py_command_reset
+  - pymdownx.highlight:
+      line_spans: __codeline
+      line_anchors: __codelineno
+      anchor_linenums: True
+  - pymdownx.inlinehilite:
+  - pymdownx.magiclink:
+      repo_url_shortener: true
+      repo_url_shorthand: true
+      social_url_shorthand: true
+      user: facelessuser
+      repo: bracex
+  - pymdownx.tilde:
+  - pymdownx.caret:
+  - pymdownx.smartsymbols:
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+  - pymdownx.escapeall:
+      hardbreak: True
+      nbsp: True
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.progressbar:
+  - pymdownx.striphtml:
+  - pymdownx.snippets:
+      base_path:
+      - docs/src/markdown/.snippets
+      - LICENSE.md
+      auto_append:
+      - refs.md
+  - pymdownx.keys:
+      separator: "\uff0b"
+  - pymdownx.saneheaders:
+  - pymdownx.blocks.admonition:
+      types:
+      - new
+      - settings
+      - note
+      - abstract
+      - info
+      - tip
+      - success
+      - question
+      - warning
+      - failure
+      - danger
+      - bug
+      - example
+      - quote
+  - pymdownx.blocks.details:
+      types:
+      - name: details-new
+        class: new
+      - name: details-settings
+        class: settings
+      - name: details-note
+        class: note
+      - name: details-abstract
+        class: abstract
+      - name: details-info
+        class: info
+      - name: details-tip
+        class: tip
+      - name: details-success
+        class: success
+      - name: details-question
+        class: question
+      - name: details-warning
+        class: warning
+      - name: details-failure
+        class: failure
+      - name: details-danger
+        class: danger
+      - name: details-bug
+        class: bug
+      - name: details-example
+        class: example
+      - name: details-quote
+        class: quote
+  - pymdownx.blocks.html:
+  - pymdownx.blocks.definition:
+  - pymdownx.blocks.tab:
+      alternate_style: True
+      combine_header_slug: True
+      slugify: !!python/object/apply:pymdownx.slugs.slugify {kwds: {case: lower}}
+  - pymdownx.quotes:
+      callouts: true
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/facelessuser
+  zensical_pymdownx:
+    sponsor: https://github.com/sponsors/facelessuser