simpleparse 3.0.0a3__tar.gz

simpleparse-3.0.0a3/MANIFEST.in

@@ -0,0 +1,18 @@
+include MANIFEST.in
+include license.txt
+include tox.ini
+include setup.py
+recursive-include simpleparse/stt COPYRIGHT LICENSE *.html 
+recursive-include simpleparse/stt/Doc *.html 
+recursive-include simpleparse/stt/TextTools/mxTextTools *.c *.h
+
+recursive-include doc *.html
+recursive-include doc *.css
+recursive-include tests *.py
+
+global-exclude *.so
+global-exclude *.pyc
+prune examples/html.py
+prune examples/py*
+prune examples/rtf*
+prune .tox

simpleparse-3.0.0a3/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: simpleparse
+Version: 3.0.0a3
+Summary: A Parser Generator for Python (w/mxTextTools derivative)
+Author-email: "Mike C. Fletcher" <mcfletch@users.sourceforge.net>
+License: BSD-3-Clause
+Project-URL: Homepage, https://mcfletch.github.io/simpleparse/
+Project-URL: Source, https://github.com/mcfletch/simpleparse
+Keywords: parse,parser,parsing,text,ebnf,grammar,generator
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: tox>=4.11; extra == "dev"
+Requires-Dist: tox-uv>=1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+
+# SimpleParse 3.x
+## A Parser Generator for Python and mxTextTools
+
+SimpleParse is a parser generator, it takes a modified EBNF
+grammar and customises a text-processing engine `mxTextTools`
+to produce a relatively fast table-driven parser.
+
+As of version 3.x, Simpleparse has moved to being unicode-native,
+with direct support for each of the 3 internal unicode formats
+that are supported by Python3 (as well as bytes format). However,
+the effect of the unicode changes is that the parser generator will
+assume unicode when generating the parser, and you will need to
+specify the content encoding when parsing/tagging.
+
+So for parsing a latin-1 document provided as raw encoded bytes:
+
+* tag(bytestream, tagtable, 'latin-1')
+
+Only utf-8 encoding is handled among multi-byte encodings, but
+single-byte encodings should be handled. Note that it is *generally*
+going to be more useful to load your document as unicode text and
+then tag the content, but the byte-stream parsing may be necessary
+if you have the content already in memory as bytes and can't 
+decode it for some reason.
+
+You can see a full-featured [sample parser](https://github.com/mcfletch/pyvrml97/blob/master/vrml/vrml97/parser.py)
+in the `PyVRML97` package.
+
+See the [docs](https://mcfletch.github.io/simpleparse/) for usage.
+
+```pip install SimpleParse```
+
+[![Appveyor Build](https://ci.appveyor.com/api/projects/status/MikeCFletcher/simpleparse?svg=True)](https://ci.appveyor.com/project/MikeCFletcher/simpleparse)
+
+[![PyPI download month](https://img.shields.io/pypi/v/simpleparse.svg)](https://pypi.python.org/pypi/simpleparse)
+
+[![PyPI download month](https://img.shields.io/pypi/dm/simpleparse.svg)](https://pypi.python.org/pypi/simpleparse/)
+

simpleparse-3.0.0a3/README.md

@@ -0,0 +1,38 @@
+# SimpleParse 3.x
+## A Parser Generator for Python and mxTextTools
+
+SimpleParse is a parser generator, it takes a modified EBNF
+grammar and customises a text-processing engine `mxTextTools`
+to produce a relatively fast table-driven parser.
+
+As of version 3.x, Simpleparse has moved to being unicode-native,
+with direct support for each of the 3 internal unicode formats
+that are supported by Python3 (as well as bytes format). However,
+the effect of the unicode changes is that the parser generator will
+assume unicode when generating the parser, and you will need to
+specify the content encoding when parsing/tagging.
+
+So for parsing a latin-1 document provided as raw encoded bytes:
+
+* tag(bytestream, tagtable, 'latin-1')
+
+Only utf-8 encoding is handled among multi-byte encodings, but
+single-byte encodings should be handled. Note that it is *generally*
+going to be more useful to load your document as unicode text and
+then tag the content, but the byte-stream parsing may be necessary
+if you have the content already in memory as bytes and can't 
+decode it for some reason.
+
+You can see a full-featured [sample parser](https://github.com/mcfletch/pyvrml97/blob/master/vrml/vrml97/parser.py)
+in the `PyVRML97` package.
+
+See the [docs](https://mcfletch.github.io/simpleparse/) for usage.
+
+```pip install SimpleParse```
+
+[![Appveyor Build](https://ci.appveyor.com/api/projects/status/MikeCFletcher/simpleparse?svg=True)](https://ci.appveyor.com/project/MikeCFletcher/simpleparse)
+
+[![PyPI download month](https://img.shields.io/pypi/v/simpleparse.svg)](https://pypi.python.org/pypi/simpleparse)
+
+[![PyPI download month](https://img.shields.io/pypi/dm/simpleparse.svg)](https://pypi.python.org/pypi/simpleparse/)
+

simpleparse-3.0.0a3/license.txt

@@ -0,0 +1,31 @@
+Includes the eGenix mxTextTools extensions, which are licensed under the 
+eGenix.com Public License see the stt/LICENSE file for details on licensing 
+terms, the eGenix extensions are:
+
+	Copyright (c) 1997-2000, Marc-Andre Lemburg; mailto:mal@lemburg.com
+	Copyright (c) 2000-2001, eGenix.com Software GmbH; mailto:info@egenix.com
+
+Copyright, License & Disclaimer for SimpleParse:
+
+	© 1998-2015, Copyright by Contributors; All Rights Reserved.
+
+	Permission to use, copy, modify, and distribute this software 
+	and its documentation for any purpose and without fee or royalty
+	is hereby granted, provided that the above copyright notice appear
+	in all copies and that both the copyright notice and this 
+	permission notice appear in supporting documentation or portions 
+	thereof, including modifications, that you make.
+
+	THE CONTRIBUTORS DISCLAIM ALL WARRANTIES WITH REGARD
+	TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF 
+	MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE 
+	LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY 
+	DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
+	WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 
+	ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 
+	PERFORMANCE OF THIS SOFTWARE!
+
+Contributors:
+
+    Mike C. Fletcher <mcfletch@vrplumber.com>
+    Anthony Tuininga

simpleparse-3.0.0a3/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=59.6", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "simpleparse"
+dynamic = ["version"]
+description = "A Parser Generator for Python (w/mxTextTools derivative)"
+authors = [
+    {name = "Mike C. Fletcher", email = "mcfletch@users.sourceforge.net"},
+]
+readme = "README.md"
+license = {text = "BSD-3-Clause"}
+keywords = ["parse", "parser", "parsing", "text", "ebnf", "grammar", "generator"]
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.8"
+
+[project.optional-dependencies]
+dev = ["pytest", "ruff", "tox>=4.11", "tox-uv>=1"]
+docs = ["sphinx", "sphinx-rtd-theme"]
+
+[project.urls]
+Homepage = "https://mcfletch.github.io/simpleparse/"
+Source = "https://github.com/mcfletch/simpleparse"
+
+[tool.setuptools]
+packages = [
+    "simpleparse",
+    "simpleparse.common",
+    "simpleparse.stt",
+    "simpleparse.stt.Doc",
+    "simpleparse.stt.TextTools",
+    "simpleparse.stt.TextTools.Constants",
+    "simpleparse.stt.TextTools.mxTextTools",
+    "simpleparse.xmlparser",
+]
+include-package-data = true
+
+[tool.setuptools.dynamic]
+version = {attr = "simpleparse.__version__"}
+
+[tool.setuptools.package-data]
+simpleparse = ["*.txt", "**/*.txt", "**/*.ebnf", "**/*.html", "**/*.pyx", "**/*.h", "**/*.def"]
+
+[tool.ruff.format]
+quote-style="preserve"
+
+[tool.ruff.lint]
+dummy-variable-rgx="^(_|err)$"
+ignore = [
+    'D200', # Allow multiline docstring even when it could fit on one line
+
+    'C408', # Allow instantiating dictionary as dict(key=value)
+    'E501', # Line too long
+    'PTH', # allow os.path
+    'PLR0913', # allow "too many" arguments
+
+    'E401', # I prefer multiple imports/line generally
+    'E402', # We often need to run setupdefaults to get django setup done
+    'F401', # unused imports, not an error, but should be cleaned up
+]

simpleparse-3.0.0a3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

simpleparse-3.0.0a3/setup.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+"""Installs SimpleParse using distutils
+
+Run:
+    python setup.py install
+to install the packages from the source archive.
+"""
+from setuptools import setup, Extension, find_packages
+import os, sys
+HERE = os.path.abspath(os.path.dirname(__file__))
+
+# Determine Python version for conditional compilation
+PY_MAJOR = sys.version_info.major
+PY_MINOR = sys.version_info.minor
+PYTHON_VERSION = (PY_MAJOR, PY_MINOR)
+
+def findVersion( ):
+    """Find the version declaration in the __init__.py file"""
+    for line in open( 
+        os.path.join( HERE, 'simpleparse', '__init__.py') 
+    ).read().splitlines():
+        if line.startswith('__version__'):
+            line = line.split('=')[1]
+            line = line.strip().strip('"').strip("'")
+            return line
+    raise RuntimeError("Unable to find __version__ declaration")
+
+options = {
+    'sdist': { 'force_manifest':1,'formats':['gztar'] },
+}
+if sys.platform == 'win32':
+    options.setdefault(
+        'build_ext',{}
+    )['define'] = 'BAD_STATIC_FORWARD'
+
+if __name__ == "__main__":
+    # Most metadata is now in pyproject.toml
+    # This setup.py is primarily for C extension configuration
+    
+    # Python 3.3+ only - use modern implementation with compatibility layer
+    print(f"Building for Python {PY_MAJOR}.{PY_MINOR}: Modern Unicode implementation")
+    
+    # Verify minimum Python version
+    if PYTHON_VERSION < (3, 3):
+        raise RuntimeError(f"SimpleParse requires Python 3.3 or later, got {PY_MAJOR}.{PY_MINOR}")
+    
+    # Use modern implementation with compatibility shims for deprecated APIs
+    sources = [
+        'simpleparse/stt/TextTools/mxTextTools/mxTextTools.c',
+        'simpleparse/stt/TextTools/mxTextTools/mxte_modern.c',
+        'simpleparse/stt/TextTools/mxTextTools/mxte_smart.c', 
+        'simpleparse/stt/TextTools/mxTextTools/mxbmse.c',
+        'simpleparse/stt/TextTools/mxTextTools/mxbm_modern.c',
+    ]
+    
+    define_macros = [
+        ('MX_BUILDING_MXTEXTTOOLS', 1),
+        ('PY_SSIZE_T_CLEAN', 1),
+    ]
+    
+    # For all Python 3.3+, force use of modern APIs and eliminate legacy compatibility
+    define_macros.append(('MODERN_UNICODE_ONLY', 1))  # Enable modern Unicode-only build
+    define_macros.append(('FORCE_MODERN_UNICODE', 1))  # Force use of modern APIs
+    
+    setup(
+        ext_modules=[
+            Extension(
+                "simpleparse.stt.TextTools.mxTextTools.mxTextTools", 
+                sources,
+                include_dirs=[
+                    'simpleparse/stt/TextTools/mxTextTools',
+                ],
+                define_macros=define_macros,
+            ),
+        ],
+        options=options,
+    )

simpleparse-3.0.0a3/simpleparse/__init__.py

@@ -0,0 +1,8 @@
+"""Simple parsing using mxTextTools
+
+See the /doc subdirectory for introductory and
+general documentation.  See license.txt for licensing
+information.  (This is a BSD-licensed package).
+"""
+
+__version__ = "3.0.0a3"

simpleparse-3.0.0a3/simpleparse/baseparser.py

@@ -0,0 +1,90 @@
+"""Base class for real-world parsers (such as parser.Parser)"""
+
+from simpleparse.stt.TextTools.TextTools import tag
+from simpleparse.generator import Generator
+
+
+class BaseParser:
+    """Class on which real-world parsers build
+
+    Normally you use a sub-class of this class, such as
+    simpleparser.parser.Parser
+    """
+
+    _rootProduction = ""
+
+    # primary API...
+    def parse(
+        self, data, production=None, processor=None, start=0, stop=None, encoding=None
+    ):
+        """Parse data with production "production" of this parser
+
+        data -- data to be parsed, a Python string or bytes
+        production -- optional string specifying a non-default production to use
+            for parsing data
+        processor -- optional pointer to a Processor or MethodSource object for
+            use in determining reporting format and/or post-processing the results
+            of the parsing pass.  Can be None if neither is desired (default)
+        start -- starting index for the parsing, default 0
+        stop -- stoping index for the parsing, default len(data)
+        encoding -- optional encoding for bytes input (e.g., 'utf-8', 'latin-1').
+            When specified with bytes input, the grammar patterns are compiled
+            to match the encoded byte sequences. Supported encodings:
+            - Single-byte: latin-1, iso-8859-*, windows-1252, ascii, etc.
+            - Multi-byte: utf-8 only (other multi-byte encodings not supported)
+            Positions in the result are byte positions when encoding is used.
+        """
+        self.resetBeforeParse()
+        if processor is None:
+            processor = self.buildProcessor()
+        if stop is None:
+            stop = len(data)
+        value = tag(
+            data,
+            self.buildTagger(production, processor),
+            start,
+            stop,
+            encoding=encoding,
+        )
+        if processor and callable(processor):
+            return processor(value, data)
+        else:
+            return value
+
+    # abstract methods
+    def buildProcessor(self):
+        """Build default processor object for this parser class
+
+        The default implementation returns None.  The processor
+        can either implement the "method source" API (just provides
+        information about Callouts and the like), or the processor
+        API and the method-source API.  The processor API merely
+        requires that the object be callable, and have the signature:
+
+            object( (success, children, nextPosition), buffer)
+
+        (Note: your object can treat the first item as a single tuple
+        if it likes).
+
+        See: simpleparse.processor module for details.
+        """
+        return None
+
+    def buildTagger(self, name, processor):
+        """Build the tag-table for the parser
+
+        This method must be implemented by your base class and _not_
+        call the implementation here.
+        """
+        raise NotImplementedError(
+            """Parser sub-class %s hasn't implemented a buildTagger method"""
+            % (self.__class__.__name__)
+        )
+
+    def resetBeforeParse(self):
+        """Called just before the parser's parse method starts working,
+
+        Allows you to set up special-purpose structures, such as stacks
+        or local storage values.  There is no base implementation.  The
+        base implementation does nothing.
+        """

simpleparse-3.0.0a3/simpleparse/common/__init__.py

@@ -0,0 +1,19 @@
+"""Common (library) definitions
+
+You normally use this module by importing one of our
+sub-modules (which automatically registers itself with
+the SOURCES list defined here).
+
+Calling common.share( dictionary ) with a dictionary
+mapping string names to element token instances will
+make the element tokens available under those string
+names in default parsers.  Note: a Parser can override
+this by specifying an explicit definitionSources
+parameter in its initialiser.
+"""
+
+def share( dictionary ):
+    SOURCES.append( dictionary)
+
+SOURCES = [
+]

simpleparse-3.0.0a3/simpleparse/common/calendar_names.py

@@ -0,0 +1,103 @@
+"""Locale-specific calendar names (day-of-week and month-of-year)
+
+These values are those returned by the calendar module.  Available
+productions:
+
+    locale_day_names
+    locale_day_names_uc
+    locale_day_names_lc
+        Names for the days of the week
+
+    locale_day_abbrs
+    locale_day_abbrs_uc
+    locale_day_abbrs_lc
+        Short-forms (3 characters normally) for
+        the days of the week.
+
+    locale_month_names
+    locale_month_names_uc
+    locale_month_names_lc
+        Names for the months of the year
+
+    locale_month_abbrs
+    locale_month_abbrs_uc
+    locale_month_abbrs_lc
+        Short-forms (3 characters normally) for
+        the months of the year
+
+Interpreters:
+    MonthNameInterpreter
+    DayNameInterpreter
+        Both offer the ability to set an index other
+        than the default (of 1) for the first item in
+        the list.
+"""
+import calendar
+from simpleparse import objectgenerator, common
+
+c = {}
+
+da = calendar.day_abbr[:]
+dn = calendar.day_name[:]
+ma = calendar.month_abbr[:]
+mn = calendar.month_name[:]
+
+def _build( name, set ):
+    # make sure longest equal-prefix items are first
+    set = set[:]
+    set.sort()
+    set.reverse()
+    l,u,r = [],[],[]
+    for item in set:
+        l.append( objectgenerator.Literal( value = item.lower() ))
+        u.append( objectgenerator.Literal( value = item.upper() ))
+        r.append( objectgenerator.Literal( value = item ))
+    c[ name + '_lc' ] = objectgenerator.FirstOfGroup( children = l )
+    c[ name + '_uc' ] = objectgenerator.FirstOfGroup( children = u )
+    c[ name ] = objectgenerator.FirstOfGroup( children = r )
+
+_build( 'locale_day_names', dn )
+_build( 'locale_day_abbrs', da )
+
+
+_build( 'locale_month_names', mn )
+_build( 'locale_month_abbrs', ma )
+
+da = [s.lower() for s in da]
+dn = [s.lower() for s in dn]
+ma = [s.lower() for s in ma]
+mn = [s.lower() for s in mn]
+
+
+common.share( c )
+
+class NameInterpreter:
+    offset = 1
+    def __init__( self, offset = 1 ):
+        self.offset = offset
+    def __call__( self, info, buffer ):
+        (tag, left, right, children) = info
+        value = buffer[left:right].lower()
+        for table in self.tables:
+            try:
+                return table.index( value )+ self.offset
+            except ValueError:
+                pass
+        raise ValueError( """Unrecognised (but parsed) %s name %s at character %s"""%( self.nameType, value, left))
+
+class MonthNameInterpreter( NameInterpreter):
+    """Interpret a month-of-year name as an integer index
+
+    Pass an "offset" value to __init__ to use an offset other
+    than 1 (Monday = 1), normally 0 (Monday = 0)
+    """
+    nameType = "Month"
+    tables = (mn,ma)
+class DayNameInterpreter( NameInterpreter ):
+    """Interpret a day-of-week name as an integer index
+
+    Pass an "offset" value to __init__ to use an offset other
+    than 1 (January = 1), normally 0 (January = 0)
+    """
+    nameType = "Day"
+    tables = (dn,da)

simpleparse-3.0.0a3/simpleparse/common/chartypes.py

@@ -0,0 +1,89 @@
+"""Common locale-specific character types
+
+Following productions are all based on string module,
+with the default locale specified.  The first production
+is a single character of the class and the second a
+repeating character version:
+
+    digit, digits
+    uppercasechar, uppercase
+    lowercasechar, lowercase
+    letter, letters
+    whitespacechar, whitespace
+    punctuationchar, punctuation
+    octdigit, octdigits
+    hexdigit, hexdigits
+    printablechar, printable
+
+For Python versions with the constants in the string module:
+    ascii_letter, ascii_letters
+    ascii_lowercasechar, ascii_lowercase
+    ascii_uppercasechar, ascii_uppercase
+
+
+Following are locale-specific values, both are
+single-character values:
+
+    locale_decimal_point -- locale-specific decimal seperator
+    locale_thousands_seperator -- locale-specific "thousands" seperator
+    
+Others:
+
+    EOF -- Matches iff parsing has reached the end of the buffer
+
+There are no interpreters provided (the types are considered
+too common to provide meaningful interpreters).
+"""
+from simpleparse import objectgenerator, common
+import string, locale
+try:
+    locale.setlocale(locale.LC_ALL, "" )
+except locale.Error:
+    # Environment requests a locale that isn't installed (common in minimal
+    # containers). localeconv() still works against the default C locale, so
+    # the only consequence is C-locale decimal/thousands conventions below.
+    pass
+
+c = {}
+
+# string-module items...
+
+for source,single,repeat in [
+    ("digits","digit","digits"),
+    ("ascii_uppercase", "uppercasechar", "uppercase"),
+    ("ascii_lowercase", "lowercasechar", "lowercase"),
+    ("ascii_letters", "letter", "letters" ),
+    ("ascii_letters", "ascii_letter", "ascii_letters" ), # alias
+    ("ascii_lowercase", "ascii_lowercasechar", "ascii_lowercase"),
+    ("ascii_uppercase", "ascii_uppercasechar", "ascii_uppercase"),
+    ("whitespace", "whitespacechar", "whitespace"),
+    ("punctuation", "punctuationchar", "punctuation"),
+    ("octdigits", "octdigit", "octdigits"),
+    ("hexdigits", "hexdigit", "hexdigits"),
+    ("printable", "printablechar", "printable"),
+]:
+    try:
+        value = getattr( string, source )
+        c[ single ] = objectgenerator.Range( value = value )
+        c[ repeat ] = objectgenerator.Range( value = value, repeating =1 )
+    except AttributeError:
+        pass
+
+# locale-module items
+_lc = locale.localeconv()
+c[ "locale_decimal_point" ] = objectgenerator.Literal( value = _lc["decimal_point"] )
+c[ "locale_thousands_seperator" ] = objectgenerator.Literal( value = _lc["thousands_sep"] )
+
+del _lc
+
+# common, but not really well defined sets
+# this is the set of characters which are interpreted
+# specially by Python's string-escaping when they
+# follow a \\ char.
+
+from simpleparse.stt import TextTools
+c[ "EOF" ] = objectgenerator.Prebuilt( value = (
+    (None, TextTools.EOF, TextTools.Here),
+) )
+
+common.share( c )