kodexa 7.4.414781565138__py3-none-any.whl → 8.0.14958192442__py3-none-any.whl

kodexa/selectors/core.py

@@ -1,124 +0,0 @@
-"""Core XPath parsing glue.
-
-"""
-
-from __future__ import unicode_literals
-
-import os
-import re
-import tempfile
-
-from ply import lex, yacc
-
-from kodexa.selectors import lexrules
-from kodexa.selectors import parserules
-
-__all__ = ["lexer", "parser", "parse"]
-
-OPERATOR_FORCERS = {
-    "PIPELINE_OP",
-    "ABBREV_AXIS_AT",
-    "AXIS_SEP",
-    "OPEN_PAREN",
-    "OPEN_BRACKET",
-    "AND_OP",
-    "OR_OP",
-    "MOD_OP",
-    "DIV_OP",
-    "MULT_OP",
-    "PATH_SEP",
-    "ABBREV_PATH_SEP",
-    "UNION_OP",
-    "PLUS_OP",
-    "MINUS_OP",
-    "EQUAL_OP",
-    "REL_OP",
-    "COLON",
-}
-
-NODE_TYPES = {"comment", "text", "processing-instruction", "node"}
-
-
-class LexerWrapper(lex.Lexer):
-    def token(self):
-        tok = lex.Lexer.token(self)
-        if tok is not None:
-            if tok.type == "STAR_OP":
-                if self.last is not None and self.last.type not in OPERATOR_FORCERS:
-                    # first half of point 1
-                    tok.type = "MULT_OP"
-
-            if tok.type == "NCNAME":
-                if self.last is not None and self.last.type not in OPERATOR_FORCERS:
-                    # second half of point 1
-                    operator = lexrules.operator_names.get(tok.value, None)
-                    if operator is not None:
-                        tok.type = operator
-                else:
-                    self_next = self.peek()
-                    if self_next is not None:
-                        if self_next.type == "OPEN_PAREN":
-                            # point 2
-                            if tok.value in NODE_TYPES:
-                                tok.type = "NODETYPE"
-                            else:
-                                tok.type = "FUNCNAME"
-                        elif self_next.type == "AXIS_SEP":
-                            # point 3
-                            tok.type = "AXISNAME"
-
-        self.last = tok
-        return tok
-
-    def peek(self):
-        clone = self.clone()
-        return clone.token()
-
-
-# try to build the lexer with cached lex table generation. this will fail if
-# the user doesn't have write perms on the source directory. in that case,
-# try again without lex table generation.
-lexdir = os.path.dirname(lexrules.__file__)
-lexer = None
-try:
-    lexer = lex.lex(module=lexrules, optimize=1, outputdir=lexdir, reflags=re.UNICODE)
-except IOError as e:
-    import errno
-
-    if e.errno != errno.EACCES:
-        raise
-if lexer is None:
-    lexer = lex.lex(module=lexrules, reflags=re.UNICODE)
-# then dynamically rewrite the lexer class to use the wonky override logic
-# above
-lexer.__class__ = LexerWrapper
-lexer.last = None
-
-# build the parser. This will generate a parsetab.py in the eulxml.xpath
-# directory. Unlike lex, though, this just logs a complaint when it fails
-# (contrast lex's explosion). Other than that, it's much less exciting
-# than the lexer wackiness.
-parsedir = os.path.dirname(parserules.__file__)
-# By default, store generated parse files with the code
-# If we don't have write permission, put them in the configured tempdir
-if not os.access(parsedir, os.W_OK):
-    parsedir = tempfile.gettempdir()
-parser = yacc.yacc(module=parserules, outputdir=parsedir, debug=0)
-
-
-def parse(xpath):
-    """Parse an xpath."""
-    # Expose the parse method of the constructed parser,
-    # but explicitly specify the lexer created here,
-    # since otherwise parse will use the most-recently created lexer.
-    return parser.parse(xpath, lexer=lexer)
-
-
-def ptokens(s):
-    """Lex a string as XPath tokens, and print each token as it is lexed.
-    This is used primarily for debugging. You probably don't want this
-    function."""
-
-    lexer.input(s)
-    for tok in lexer:
-        print(tok)

kodexa/selectors/lexrules.py

@@ -1,137 +0,0 @@
-"""XPath lexing rules.
-
-To understand how this module works, it is valuable to have a strong
-understanding of the `ply <http://www.dabeaz.com/ply/>` module.
-"""
-
-from __future__ import unicode_literals
-
-operator_names = {
-    "or": "OR_OP",
-    "and": "AND_OP",
-    "div": "DIV_OP",
-    "mod": "MOD_OP",
-    "intersect": "INTERSECT_OP",
-    "stream": "PIPELINE_OP",
-}
-
-tokens = [
-    "PATH_SEP",
-    "ABBREV_PATH_SEP",
-    "ABBREV_STEP_SELF",
-    "ABBREV_STEP_PARENT",
-    "AXIS_SEP",
-    "ABBREV_AXIS_AT",
-    "OPEN_PAREN",
-    "CLOSE_PAREN",
-    "OPEN_BRACKET",
-    "CLOSE_BRACKET",
-    "UNION_OP",
-    "EQUAL_OP",
-    "REL_OP",
-    "INTERSECT_OP",
-    "PLUS_OP",
-    "MINUS_OP",
-    "MULT_OP",
-    "STAR_OP",
-    "COMMA",
-    "LITERAL",
-    "FLOAT",
-    "INTEGER",
-    "NCNAME",
-    "NODETYPE",
-    "FUNCNAME",
-    "AXISNAME",
-    "COLON",
-    "DOLLAR",
-] + list(operator_names.values())
-
-t_PATH_SEP = r"/"
-t_ABBREV_PATH_SEP = r"//"
-t_ABBREV_STEP_SELF = r"\."
-t_ABBREV_STEP_PARENT = r"\.\."
-t_AXIS_SEP = r"::"
-t_ABBREV_AXIS_AT = r"@"
-t_OPEN_PAREN = r"\("
-t_CLOSE_PAREN = r"\)"
-t_OPEN_BRACKET = r"\["
-t_CLOSE_BRACKET = r"\]"
-t_UNION_OP = r"\|"
-t_EQUAL_OP = r"!?="
-t_REL_OP = r"[<>]=?"
-t_PLUS_OP = r"\+"
-t_MINUS_OP = r"-"
-t_COMMA = r","
-t_COLON = r":"
-t_DOLLAR = r"\$"
-t_STAR_OP = r"\*"
-
-t_ignore = " \t\r\n"
-
-# NOTE: some versions of python cannot compile regular expressions that
-# contain unicode characters above U+FFFF, which are allowable in NCNames.
-# These characters can be used in Python 2.6.4, but can NOT be used in 2.6.2
-# (status in 2.6.3 is unknown).  The code below accounts for that and excludes
-# the higher character range if Python can't handle it.
-
-# Monster regex derived from:
-#  http://www.w3.org/TR/REC-xml/#NT-NameStartChar
-#  http://www.w3.org/TR/REC-xml/#NT-NameChar
-# EXCEPT:
-# Technically those productions allow ':'. NCName, on the other hand:
-#  http://www.w3.org/TR/REC-xml-names/#NT-NCName
-# explicitly excludes those names that have ':'. We implement this by
-# simply removing ':' from our regexes.
-
-# NameStartChar regex without characters about U+FFFF
-NameStartChar = (
-    r"[A-Z]|_|[a-z]|\xc0-\xd6]|[\xd8-\xf6]|[\xf8-\u02ff]|"
-    + r"[\u0370-\u037d]|[\u037f-\u1fff]|[\u200c-\u200d]|[\u2070-\u218f]|"
-    + r"[\u2c00-\u2fef]|[\u3001-\uD7FF]|[\uF900-\uFDCF]|[\uFDF0-\uFFFD]"
-)
-# complete NameStartChar regex
-Full_NameStartChar = r"(" + NameStartChar + r"|[\U00010000-\U000EFFFF]" + r")"
-# additional characters allowed in NCNames after the first character
-NameChar_extras = r"[-.0-9\xb7\u0300-\u036f\u203f-\u2040]"
-
-try:
-    import re
-
-    # test whether or not re can compile unicode characters above U+FFFF
-    re.compile(r"[\U00010000-\U00010001]")
-    # if that worked, then use the full ncname regex
-    NameStartChar = Full_NameStartChar
-except:
-    # if compilation failed, leave NameStartChar regex as is, which does not
-    # include the unicode character ranges above U+FFFF
-    pass
-
-NCNAME_REGEX = (
-    r"(" + NameStartChar + r")(" + NameStartChar + r"|" + NameChar_extras + r")*"
-)
-
-NODE_TYPES = set(["comment", "text", "processing-instruction", "node"])
-
-t_NCNAME = NCNAME_REGEX
-
-
-def t_LITERAL(t):
-    r""" "[^"]*"|'[^']*'"""
-    t.value = t.value[1:-1]
-    return t
-
-
-def t_FLOAT(t):
-    r"\d+\.\d*|\.\d+"
-    t.value = float(t.value)
-    return t
-
-
-def t_INTEGER(t):
-    r"\d+"
-    t.value = int(t.value)
-    return t
-
-
-def t_error(t):
-    raise TypeError("Unknown text '%s'" % (t.value,))

kodexa/selectors/lextab.py

@@ -1,83 +0,0 @@
-# lextab.py. This file automatically created by PLY (version 3.11). Don't edit!
-_tabversion = "3.10"
-_lextokens = set(
-    (
-        "ABBREV_AXIS_AT",
-        "ABBREV_PATH_SEP",
-        "ABBREV_STEP_PARENT",
-        "ABBREV_STEP_SELF",
-        "AND_OP",
-        "AXISNAME",
-        "AXIS_SEP",
-        "CLOSE_BRACKET",
-        "CLOSE_PAREN",
-        "COLON",
-        "COMMA",
-        "DIV_OP",
-        "DOLLAR",
-        "EQUAL_OP",
-        "FLOAT",
-        "FUNCNAME",
-        "INTEGER",
-        "INTERSECT_OP",
-        "LITERAL",
-        "MINUS_OP",
-        "MOD_OP",
-        "MULT_OP",
-        "NCNAME",
-        "NODETYPE",
-        "OPEN_BRACKET",
-        "OPEN_PAREN",
-        "OR_OP",
-        "PATH_SEP",
-        "PIPELINE_OP",
-        "PLUS_OP",
-        "REL_OP",
-        "STAR_OP",
-        "UNION_OP",
-    )
-)
-_lexreflags = 32
-_lexliterals = ""
-_lexstateinfo = {"INITIAL": "inclusive"}
-_lexstatere = {
-    "INITIAL": [
-        (
-            "(?P<t_LITERAL>\"[^\"]*\"|'[^']*')|(?P<t_FLOAT>\\d+\\.\\d*|\\.\\d+)|(?P<t_INTEGER>\\d+)|(?P<t_NCNAME>(([A-Z]|_|[a-z]|\\xc0-\\xd6]|[\\xd8-\\xf6]|[\\xf8-\\u02ff]|[\\u0370-\\u037d]|[\\u037f-\\u1fff]|[\\u200c-\\u200d]|[\\u2070-\\u218f]|[\\u2c00-\\u2fef]|[\\u3001-\\uD7FF]|[\\uF900-\\uFDCF]|[\\uFDF0-\\uFFFD]|[\\U00010000-\\U000EFFFF]))(([A-Z]|_|[a-z]|\\xc0-\\xd6]|[\\xd8-\\xf6]|[\\xf8-\\u02ff]|[\\u0370-\\u037d]|[\\u037f-\\u1fff]|[\\u200c-\\u200d]|[\\u2070-\\u218f]|[\\u2c00-\\u2fef]|[\\u3001-\\uD7FF]|[\\uF900-\\uFDCF]|[\\uFDF0-\\uFFFD]|[\\U00010000-\\U000EFFFF])|[-.0-9\\xb7\\u0300-\\u036f\\u203f-\\u2040])*)|(?P<t_REL_OP>[<>]=?)|(?P<t_ABBREV_STEP_PARENT>\\.\\.)|(?P<t_EQUAL_OP>!?=)|(?P<t_ABBREV_PATH_SEP>//)|(?P<t_ABBREV_STEP_SELF>\\.)|(?P<t_AXIS_SEP>::)|(?P<t_CLOSE_BRACKET>\\])|(?P<t_CLOSE_PAREN>\\))|(?P<t_DOLLAR>\\$)|(?P<t_OPEN_BRACKET>\\[)|(?P<t_OPEN_PAREN>\\()|(?P<t_PIPELINE_OP>::)|(?P<t_PLUS_OP>\\+)|(?P<t_STAR_OP>\\*)|(?P<t_UNION_OP>\\|)|(?P<t_ABBREV_AXIS_AT>@)|(?P<t_COLON>:)|(?P<t_COMMA>,)|(?P<t_MINUS_OP>-)|(?P<t_PATH_SEP>/)",
-            [
-                None,
-                ("t_LITERAL", "LITERAL"),
-                ("t_FLOAT", "FLOAT"),
-                ("t_INTEGER", "INTEGER"),
-                (None, "NCNAME"),
-                None,
-                None,
-                None,
-                None,
-                (None, "REL_OP"),
-                (None, "ABBREV_STEP_PARENT"),
-                (None, "EQUAL_OP"),
-                (None, "ABBREV_PATH_SEP"),
-                (None, "ABBREV_STEP_SELF"),
-                (None, "AXIS_SEP"),
-                (None, "CLOSE_BRACKET"),
-                (None, "CLOSE_PAREN"),
-                (None, "DOLLAR"),
-                (None, "OPEN_BRACKET"),
-                (None, "OPEN_PAREN"),
-                (None, "PIPELINE_OP"),
-                (None, "PLUS_OP"),
-                (None, "STAR_OP"),
-                (None, "UNION_OP"),
-                (None, "ABBREV_AXIS_AT"),
-                (None, "COLON"),
-                (None, "COMMA"),
-                (None, "MINUS_OP"),
-                (None, "PATH_SEP"),
-            ],
-        )
-    ]
-}
-_lexstateignore = {"INITIAL": " \t\r\n"}
-_lexstateerrorf = {"INITIAL": "t_error"}
-_lexstateeoff = {}

kodexa/selectors/lextab.pyi

@@ -1 +0,0 @@
-# Empty on purpose to stop mypy analyzing the generated file