Intermediate changes

commit_hash:16645c680befa673cec2481eceae5781024fdb0e

Author: robot-piglet

contrib/python/pyparsing/py3/.dist-info/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyparsing
-Version: 3.2.0
+Version: 3.2.1
 Summary: pyparsing module - Classes and methods to define and execute parsing grammars
 Author-email: Paul McGuire <ptmcg.gm+pyparsing@gmail.com>
 Requires-Python: >=3.9

contrib/python/pyparsing/py3/pyparsing/__init__.py

@@ -120,8 +120,8 @@ def __repr__(self):
         return f"{__name__}.{type(self).__name__}({', '.join('{}={!r}'.format(*nv) for nv in zip(self._fields, self))})"
 
 
-__version_info__ = version_info(3, 2, 0, "final", 1)
-__version_time__ = "13 Oct 2024 09:46 UTC"
+__version_info__ = version_info(3, 2, 1, "final", 1)
+__version_time__ = "31 Dec 2024 20:41 UTC"
 __version__ = __version_info__.__version__
 __versionTime__ = __version_time__
 __author__ = "Paul McGuire <ptmcg.gm+pyparsing@gmail.com>"

contrib/python/pyparsing/py3/pyparsing/actions.py

@@ -1,21 +1,34 @@
 # actions.py
+from __future__ import annotations
+
+from typing import Union, Callable, Any
 
 from .exceptions import ParseException
 from .util import col, replaced_by_pep8
+from .results import ParseResults
+
+
+ParseAction = Union[
+    Callable[[], Any],
+    Callable[[ParseResults], Any],
+    Callable[[int, ParseResults], Any],
+    Callable[[str, int, ParseResults], Any],
+]
 
 
 class OnlyOnce:
     """
     Wrapper for parse actions, to ensure they are only called once.
+    Note: parse action signature must include all 3 arguments.
     """
 
-    def __init__(self, method_call):
+    def __init__(self, method_call: Callable[[str, int, ParseResults], Any]):
         from .core import _trim_arity
 
         self.callable = _trim_arity(method_call)
         self.called = False
 
-    def __call__(self, s, l, t):
+    def __call__(self, s: str, l: int, t: ParseResults) -> ParseResults:
         if not self.called:
             results = self.callable(s, l, t)
             self.called = True
@@ -30,20 +43,20 @@ def reset(self):
         self.called = False
 
 
-def match_only_at_col(n):
+def match_only_at_col(n: int) -> ParseAction:
     """
     Helper method for defining parse actions that require matching at
     a specific column in the input text.
     """
 
-    def verify_col(strg, locn, toks):
+    def verify_col(strg: str, locn: int, toks: ParseResults) -> None:
         if col(locn, strg) != n:
             raise ParseException(strg, locn, f"matched token not at column {n}")
 
     return verify_col
 
 
-def replace_with(repl_str):
+def replace_with(repl_str: str) -> ParseAction:
     """
     Helper method for common parse actions that simply return
     a literal value.  Especially useful when used with
@@ -60,7 +73,7 @@ def replace_with(repl_str):
     return lambda s, l, t: [repl_str]
 
 
-def remove_quotes(s, l, t):
+def remove_quotes(s: str, l: int, t: ParseResults) -> Any:
     """
     Helper parse action for removing quotation marks from parsed
     quoted strings.
@@ -77,7 +90,7 @@ def remove_quotes(s, l, t):
     return t[0][1:-1]
 
 
-def with_attribute(*args, **attr_dict):
+def with_attribute(*args: tuple[str, str], **attr_dict) -> ParseAction:
     """
     Helper to create a validating parse action to be used with start
     tags created with :class:`make_xml_tags` or
@@ -133,17 +146,17 @@ def with_attribute(*args, **attr_dict):
         1 4 0 1 0
         1,3 2,3 1,1
     """
+    attrs_list: list[tuple[str, str]] = []
     if args:
-        attrs = args[:]
+        attrs_list.extend(args)
     else:
-        attrs = attr_dict.items()
-    attrs = [(k, v) for k, v in attrs]
+        attrs_list.extend(attr_dict.items())
 
-    def pa(s, l, tokens):
-        for attrName, attrValue in attrs:
+    def pa(s: str, l: int, tokens: ParseResults) -> None:
+        for attrName, attrValue in attrs_list:
             if attrName not in tokens:
                 raise ParseException(s, l, "no matching attribute " + attrName)
-            if attrValue != with_attribute.ANY_VALUE and tokens[attrName] != attrValue:
+            if attrValue != with_attribute.ANY_VALUE and tokens[attrName] != attrValue:  # type: ignore [attr-defined]
                 raise ParseException(
                     s,
                     l,
@@ -156,7 +169,7 @@ def pa(s, l, tokens):
 with_attribute.ANY_VALUE = object()  # type: ignore [attr-defined]
 
 
-def with_class(classname, namespace=""):
+def with_class(classname: str, namespace: str = "") -> ParseAction:
     """
     Simplified version of :class:`with_attribute` when
     matching on a div class - made difficult because ``class`` is

contrib/python/pyparsing/py3/pyparsing/common.py

@@ -210,14 +210,14 @@ class pyparsing_common:
     """any numeric expression, returns the corresponding Python type"""
 
     fnumber = (
-        Regex(r"[+-]?\d+\.?\d*([eE][+-]?\d+)?")
+        Regex(r"[+-]?\d+\.?\d*(?:[eE][+-]?\d+)?")
         .set_name("fnumber")
         .set_parse_action(convert_to_float)
     )
     """any int or real number, returned as float"""
 
     ieee_float = (
-        Regex(r"(?i)[+-]?((\d+\.?\d*(e[+-]?\d+)?)|nan|inf(inity)?)")
+        Regex(r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))")
         .set_name("ieee_float")
         .set_parse_action(convert_to_float)
     )

contrib/python/pyparsing/py3/pyparsing/core.py

@@ -215,12 +215,7 @@ def _should_enable_warnings(
 _generatorType = types.GeneratorType
 ParseImplReturnType = tuple[int, Any]
 PostParseReturnType = Union[ParseResults, Sequence[ParseResults]]
-ParseAction = Union[
-    Callable[[], Any],
-    Callable[[ParseResults], Any],
-    Callable[[int, ParseResults], Any],
-    Callable[[str, int, ParseResults], Any],
-]
+
 ParseCondition = Union[
     Callable[[], bool],
     Callable[[ParseResults], bool],
@@ -486,6 +481,7 @@ def __init__(self, savelist: bool = False):
         self.callPreparse = True
         self.callDuringTry = False
         self.suppress_warnings_: list[Diagnostics] = []
+        self.show_in_diagram = True
 
     def suppress_warning(self, warning_type: Diagnostics) -> ParserElement:
         """
@@ -5558,7 +5554,8 @@ def __or__(self, other) -> ParserElement:
             not in self.suppress_warnings_
         ):
             warnings.warn(
-                "using '<<' operator with '|' is probably an error, use '<<='",
+                "warn_on_match_first_with_lshift_operator:"
+                " using '<<' operator with '|' is probably an error, use '<<='",
                 stacklevel=2,
             )
         ret = super().__or__(other)
@@ -5572,7 +5569,8 @@ def __del__(self):
             and Diagnostics.warn_on_assignment_to_Forward not in self.suppress_warnings_
         ):
             warnings.warn_explicit(
-                "Forward defined here but no expression attached later using '<<=' or '<<'",
+                "warn_on_assignment_to_Forward:"
+                " Forward defined here but no expression attached later using '<<=' or '<<'",
                 UserWarning,
                 filename=self.caller_frame.filename,
                 lineno=self.caller_frame.lineno,
@@ -5600,7 +5598,8 @@ def parseImpl(self, instring, loc, do_actions=True) -> ParseImplReturnType:
             else:
                 stacklevel = 2
             warnings.warn(
-                "Forward expression was never assigned a value, will not parse any input",
+                "warn_on_parse_using_empty_Forward:"
+                " Forward expression was never assigned a value, will not parse any input",
                 stacklevel=stacklevel,
             )
         if not ParserElement._left_recursion_enabled:
@@ -6157,7 +6156,7 @@ def autoname_elements() -> None:
     Utility to simplify mass-naming of parser elements, for
     generating railroad diagram with named subdiagrams.
     """
-    calling_frame = sys._getframe().f_back
+    calling_frame = sys._getframe(1)
     if calling_frame is None:
         return
     calling_frame = typing.cast(types.FrameType, calling_frame)