Add a function for defining a functions sequence types

  - Update release info

Author: brunato

CHANGELOG.rst

@@ -2,6 +2,11 @@
 CHANGELOG
 *********
 
+`v5.1.1`_ (2025-01-20)
+======================
+* Fix external function registrations (issue #099)
+* Add ExternalFunction and SchemaConstructor token classes
+
 `v5.1.0`_ (2025-12-28)
 ======================
 * Drop Python 3.9 compatibility and add Pyton 3.15 support
@@ -531,3 +536,4 @@ CHANGELOG
 .. _v5.0.3: https://github.com/sissaschool/elementpath/compare/v5.0.2...v5.0.3
 .. _v5.0.4: https://github.com/sissaschool/elementpath/compare/v5.0.3...v5.0.4
 .. _v5.1.0: https://github.com/sissaschool/elementpath/compare/v5.0.4...v5.1.0
+.. _v5.1.1: https://github.com/sissaschool/elementpath/compare/v5.1.0...v5.1.1

elementpath/sequence_types.py

@@ -15,7 +15,7 @@
 
 from elementpath.datatypes import builtin_atomic_types, builtin_list_types, QName, \
     NumericProxy, AnyAtomicType
-from elementpath.exceptions import ElementPathKeyError, xpath_error
+from elementpath.exceptions import ElementPathKeyError, ElementPathValueError, xpath_error
 from elementpath.namespaces import XSD_NAMESPACE, XSD_ERROR, XSD_DATETIME_STAMP, \
     XSD_NUMERIC, XSD_UNTYPED, XSD_UNTYPED_ATOMIC, get_expanded_name
 from elementpath.helpers import collapse_white_spaces, Patterns
@@ -36,6 +36,53 @@
 )
 
 
+def get_function_signatures(qname: QName,
+                            nargs: ta.NargsType,
+                            sequence_types: tuple[str, ...] = ()) -> dict[tuple[QName, int], str]:
+    """
+    Returns the signatures for a function.
+
+    :param qname: A QName instance that represents the FQDN of the function.
+    :param nargs: The number of arguments that the function takes, could the `None`, \
+    a non-negative integer or a couple non-negative integers or a non-negative integer \
+    followed by `None`.
+    :param sequence_types: A sequence of sequence type specifications, must match \
+    the number of arguments that the function takes plus the return type.
+    """
+    function_signatures: dict[tuple[QName, int], str] = {}
+    if not sequence_types:
+        return function_signatures
+
+    if any(not is_sequence_type(st) for st in sequence_types):
+        msg = "Error in provided sequence types: {!r}"
+        raise ElementPathValueError(msg.format(sequence_types))
+    elif nargs is None:
+        if len(sequence_types) != 1:
+            raise ElementPathValueError("Mismatched number of sequence types provided")
+        function_signatures[(qname, 0)] = f'function() as {sequence_types[0]}'
+    elif isinstance(nargs, int):
+        if len(sequence_types) != nargs + 1:
+            raise ElementPathValueError("Mismatched number of sequence types provided")
+        function_signatures[(qname, nargs)] = 'function({}) as {}'.format(
+            ', '.join(sequence_types[:-1]), sequence_types[-1]
+        )
+    elif nargs[1] is None:
+        if len(sequence_types) != nargs[0] + 1:
+            raise ElementPathValueError("Mismatched number of sequence types provided")
+        function_signatures[(qname, nargs[0])] = 'function({}, ...) as {}'.format(
+            ', '.join(sequence_types[:-1]), sequence_types[-1]
+        )
+    else:
+        if len(sequence_types) != nargs[1] + 1:
+            raise ElementPathValueError("Mismatched number of sequence types provided")
+        for arity in range(nargs[0], nargs[1] + 1):
+            function_signatures[(qname, arity)] = 'function({}) as {}'.format(
+                ', '.join(sequence_types[:arity]), sequence_types[-1]
+            )
+
+    return function_signatures
+
+
 ###
 # Sequence type checking
 @cache

elementpath/tdop.py

@@ -14,9 +14,9 @@
 import re
 from abc import ABCMeta
 from collections.abc import Callable, Iterator, MutableMapping, MutableSequence
-from unicodedata import name as unicode_name
 from decimal import Decimal, DecimalException
 from typing import Any, cast, overload, Generic, TypeVar
+from unicodedata import name as unicode_name
 
 #
 # Simple top-down parser based on Vaughan Pratt's algorithm (Top Down Operator Precedence).
@@ -49,7 +49,7 @@ class ParseError(SyntaxError):
     """An error when parsing source with TDOP parser."""
 
 
-def _symbol_to_classname(symbol: str) -> str:
+def symbol_to_classname(symbol: str) -> str:
     """
     Converts a symbol string to an identifier (only alphanumeric and '_').
     """
@@ -693,7 +693,7 @@ def register(cls, symbol: str | type[TK_co], **kwargs: Any) -> type[TK_co]:
                     token_class_name = kwargs.pop('class_name')
                 else:
                     token_class_name = "_%s%s" % (
-                        _symbol_to_classname(symbol),
+                        symbol_to_classname(symbol),
                         str(label).title().replace(' ', '')
                     )
 
@@ -713,8 +713,13 @@ def register(cls, symbol: str | type[TK_co], **kwargs: Any) -> type[TK_co]:
             raise TypeError("A string or a %r subclass requested, not %r." % (Token, symbol))
         else:
             token_class = symbol
-            if cls.symbol_table.get(symbol.lookup_name) is not token_class:
-                raise ValueError("Token class %r is not registered." % token_class)
+            lookup_name = token_class.lookup_name
+
+            if lookup_name not in cls.symbol_table:
+                cls.symbol_table[lookup_name] = token_class
+            elif cls.symbol_table[lookup_name] is not token_class:
+                msg = "Token class {!r} collide on key {!r} with a different token class."
+                raise ValueError(msg.format(token_class, lookup_name))
 
         for key, value in kwargs.items():
             if key == 'lbp' and value > token_class.lbp:

elementpath/xpath1/xpath1_parser.py

@@ -24,7 +24,7 @@
 from elementpath.collations import UNICODE_CODEPOINT_COLLATION
 from elementpath.datatypes import QName
 from elementpath.tdop import Parser
-from elementpath.sequence_types import match_sequence_type
+from elementpath.sequence_types import get_function_signatures, match_sequence_type
 from elementpath.schema_proxy import AbstractSchemaProxy
 from elementpath.xpath_tokens import XPathToken, XPathAxis, XPathFunction, ProxyToken, \
     NameToken, PrefixedNameToken, BracedNameToken
@@ -218,27 +218,11 @@ def function(cls, symbol: str,
 
         if sequence_types:
             # Register function signature(s)
+            cls.function_signatures.update(
+                get_function_signatures(qname, nargs, sequence_types)
+            )
             kwargs['sequence_types'] = sequence_types
 
-            if nargs is None:
-                pass  # pragma: no cover
-            elif isinstance(nargs, int):
-                assert len(sequence_types) == nargs + 1
-                cls.function_signatures[(qname, nargs)] = 'function({}) as {}'.format(
-                    ', '.join(sequence_types[:-1]), sequence_types[-1]
-                )
-            elif nargs[1] is None:
-                assert len(sequence_types) == nargs[0] + 1
-                cls.function_signatures[(qname, nargs[0])] = 'function({}, ...) as {}'.format(
-                    ', '.join(sequence_types[:-1]), sequence_types[-1]
-                )
-            else:
-                assert len(sequence_types) == nargs[1] + 1
-                for arity in range(nargs[0], nargs[1] + 1):
-                    cls.function_signatures[(qname, arity)] = 'function({}) as {}'.format(
-                        ', '.join(sequence_types[:arity]), sequence_types[-1]
-                    )
-
         return cast(type[XPathFunction], cls.register(symbol, **kwargs))
 
     def parse(self, source: str) -> XPathToken:

elementpath/xpath2/xpath2_parser.py

@@ -28,7 +28,8 @@
 from elementpath.collations import UNICODE_COLLATION_BASE_URI, UNICODE_CODEPOINT_COLLATION
 from elementpath.xpath_tokens import XPathToken, ProxyToken, XPathFunction, \
     XPathConstructor, SchemaConstructor, ExternalFunction
-from elementpath.sequence_types import is_sequence_type, match_sequence_type
+from elementpath.sequence_types import get_function_signatures, is_sequence_type, \
+    match_sequence_type
 from elementpath.schema_proxy import AbstractSchemaProxy
 from elementpath.xpath1 import XPath1Parser
 
@@ -274,7 +275,7 @@ def bind(func: Callable[..., Any]) -> Callable[..., Any]:
             return func
         return bind
 
-    def dynamic_register(self, symbol: str, class_name: str, **kwargs: Any) \
+    def _register(self, symbol: str, class_name: str, **kwargs: Any) \
             -> type[ta.XPathTokenType]:
         """
         Register/update a token class in the symbol table of a parser instance.
@@ -328,7 +329,7 @@ def schema_constructor(self, atomic_type_name: str, bp: int = 90) -> type[XPathF
             'lbp': bp,
             'rbp': bp,
         }
-        return cast(type[XPathFunction], self.dynamic_register(symbol, class_name, **kwargs))
+        return cast(type[XPathFunction], self._register(symbol, class_name, **kwargs))
 
     def external_function(self,
                           callback: Callable[..., Any],
@@ -364,27 +365,7 @@ def external_function(self,
             namespace = XPATH_FUNCTIONS_NAMESPACE
             qname = QName(XPATH_FUNCTIONS_NAMESPACE, f'fn:{symbol}')
 
-        function_signatures: dict[tuple[QName, int], str] = {}
-        if sequence_types:
-            if nargs is None:
-                assert len(sequence_types) == 1
-                function_signatures[(qname, 0)] = f'function() as {sequence_types[0]}'
-            elif isinstance(nargs, int):
-                assert len(sequence_types) == nargs + 1
-                function_signatures[(qname, nargs)] = 'function({}) as {}'.format(
-                    ', '.join(sequence_types[:-1]), sequence_types[-1]
-                )
-            elif nargs[1] is None:
-                assert len(sequence_types) == nargs[0] + 1
-                function_signatures[(qname, nargs[0])] = 'function({}, ...) as {}'.format(
-                    ', '.join(sequence_types[:-1]), sequence_types[-1]
-                )
-            else:
-                assert len(sequence_types) == nargs[1] + 1
-                for arity in range(nargs[0], nargs[1] + 1):
-                    function_signatures[(qname, arity)] = 'function({}) as {}'.format(
-                        ', '.join(sequence_types[:arity]), sequence_types[-1]
-                    )
+        function_signatures = get_function_signatures(qname, nargs, sequence_types)
 
         if qname.expanded_name in self.symbol_table:
             msg = f'function {qname.qname!r} is already registered'
@@ -414,7 +395,7 @@ def external_function(self,
                     'lbp': bp,
                     'rbp': bp,
                 }
-                self.dynamic_register(symbol, class_name, **kwargs)
+                self._register(symbol, class_name, **kwargs)
 
         class_name = f'{upper_camel_case(qname.qname)}ExternalFunction'
         kwargs = {
@@ -428,7 +409,7 @@ def external_function(self,
             'sequence_types': sequence_types,
             'callback': staticmethod(callback),
         }
-        token_class = self.dynamic_register(symbol, class_name, **kwargs)
+        token_class = self._register(symbol, class_name, **kwargs)
 
         if function_signatures:
             # Register function signatures

elementpath/xpath_tokens/functions.py

@@ -236,7 +236,7 @@ def nud(self) -> 'XPathFunction':
         if not self.parser.parse_arguments:
             return self
 
-        code = 'XPST0017' if self.label == 'function' else 'XPST0003'
+        code = 'XPST0017' if 'function' in self.label else 'XPST0003'
         self.parser.advance('(')
         if self.nargs is None:
             del self._items[:]

publiccode.yml

@@ -7,7 +7,7 @@ name: elementpath
 url: 'https://github.com/sissaschool/elementpath'
 landingURL: 'https://github.com/sissaschool/elementpath'
 releaseDate: '2025-12-28'
-softwareVersion: v5.1.0
+softwareVersion: v5.1.1
 developmentStatus: stable
 platforms:
   - linux

tests/test_tdop_parser.py

@@ -13,7 +13,7 @@
 import sys
 from collections import namedtuple
 
-from elementpath.tdop import _symbol_to_classname, ParseError, Token, \
+from elementpath.tdop import symbol_to_classname, ParseError, Token, \
     ParserMeta, Parser, MultiLabel
 
 
@@ -68,21 +68,21 @@ def test_multi_label_class(self):
         self.assertFalse(label.endswith('constructor'))
 
     def test_symbol_to_classname_function(self):
-        self.assertEqual(_symbol_to_classname('_cat10'), 'Cat10')
-        self.assertEqual(_symbol_to_classname('&'), 'Ampersand')
-        self.assertEqual(_symbol_to_classname('('), 'LeftParenthesis')
-        self.assertEqual(_symbol_to_classname(')'), 'RightParenthesis')
+        self.assertEqual(symbol_to_classname('_cat10'), 'Cat10')
+        self.assertEqual(symbol_to_classname('&'), 'Ampersand')
+        self.assertEqual(symbol_to_classname('('), 'LeftParenthesis')
+        self.assertEqual(symbol_to_classname(')'), 'RightParenthesis')
 
-        self.assertEqual(_symbol_to_classname('(name)'), 'Name')
-        self.assertEqual(_symbol_to_classname('(name'), 'LeftParenthesisname')
+        self.assertEqual(symbol_to_classname('(name)'), 'Name')
+        self.assertEqual(symbol_to_classname('(name'), 'LeftParenthesisname')
 
-        self.assertEqual(_symbol_to_classname('-'), 'HyphenMinus')
-        self.assertEqual(_symbol_to_classname('_'), 'LowLine')
-        self.assertEqual(_symbol_to_classname('-_'), 'HyphenMinusLowLine')
-        self.assertEqual(_symbol_to_classname('--'), 'HyphenMinusHyphenMinus')
+        self.assertEqual(symbol_to_classname('-'), 'HyphenMinus')
+        self.assertEqual(symbol_to_classname('_'), 'LowLine')
+        self.assertEqual(symbol_to_classname('-_'), 'HyphenMinusLowLine')
+        self.assertEqual(symbol_to_classname('--'), 'HyphenMinusHyphenMinus')
 
-        self.assertEqual(_symbol_to_classname('my-api-call'), 'MyApiCall')
-        self.assertEqual(_symbol_to_classname('call-'), 'Call')
+        self.assertEqual(symbol_to_classname('my-api-call'), 'MyApiCall')
+        self.assertEqual(symbol_to_classname('call-'), 'Call')
 
     def test_create_tokenizer_method(self):
         FakeToken = namedtuple('Token', 'symbol pattern label')
@@ -336,10 +336,13 @@ class AnotherParser(Parser):
             AnotherParser.register(9)
         self.assertIn("A string or a", str(ec.exception))
 
+        AnotherParser.register(self.parser.symbol_table['+'])
+        AnotherParser.symbol_table['-'] = self.parser.symbol_table['+']
+
         with self.assertRaises(ValueError) as ec:
-            AnotherParser.register(self.parser.symbol_table['+'])
+            AnotherParser.register(self.parser.symbol_table['-'])
         self.assertIn("Token class ", str(ec.exception))
-        self.assertIn("is not registered", str(ec.exception))
+        self.assertIn("collide", str(ec.exception))
 
     def test_other_operators(self):