simpleparse 3.0.0a3__cp313-cp313-win32.whl

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/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/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/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/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 )

simpleparse/common/comments.py

@@ -0,0 +1,72 @@
+"""Common comment formats
+
+To process, handle the "comment" production,
+(the specific named comment formats are all
+expanded productions, so you won't get them
+returned for processing).
+
+    hash_comment
+        # to EOL comments
+    slashslash_comment
+        // to EOL comments
+    semicolon_comment
+        ; to EOL comments
+    slashbang_comment
+    c_comment
+        non-nesting /* */ comments
+    slashbang_nest_comment
+    c_nest_comment
+        nesting /* /* */ */ comments
+"""
+from simpleparse.parser import Parser
+from simpleparse import common, objectgenerator
+from simpleparse.common import chartypes
+
+c = {}
+
+eolcomments = r"""
+### comment formats where the comment goes
+### from a marker to the end of the line
+
+comment   := -'\012'*
+<EOL>       := ('\r'?,'\n')/EOF
+
+>hash_comment< := '#', comment, EOL
+>semicolon_comment< := ';', comment, EOL
+>slashslash_comment< := '//', comment, EOL
+"""
+
+_p = Parser( eolcomments )
+for name in ["hash_comment", "semicolon_comment", "slashslash_comment"]:
+    c[ name ] = objectgenerator.LibraryElement(
+        generator = _p._generator,
+        production = name,
+    )
+
+ccomments = r"""
+### comments in format /* comment */ with no recursion allowed
+comment := -"*/"*
+>slashbang_comment< := '/*', comment, '*/'
+"""
+_p = Parser( ccomments )
+for name in ["c_comment","slashbang_comment"]:
+    c[ name ] = objectgenerator.LibraryElement(
+        generator = _p._generator,
+        production = "slashbang_comment",
+    )
+
+nccomments = r"""
+### nestable C comments of form /* comment /* innercomment */ back to previous */
+<comment_start>          := '/*'
+<comment_stop>           := '*/'
+comment                  := (-(comment_stop/comment_start)+/slashbang_nest_comment)*
+>slashbang_nest_comment< := comment_start, comment, comment_stop
+"""
+_p = Parser( nccomments )
+for name in ["c_nest_comment","slashbang_nest_comment"]:
+    c[ name ] = objectgenerator.LibraryElement(
+        generator = _p._generator,
+        production = "slashbang_nest_comment",
+    )
+
+common.share(c)

simpleparse/common/escapeutils.py

@@ -0,0 +1,21 @@
+"""Shared escape sequence utilities for SimpleParse
+
+This module provides common escape sequence mappings used by both
+the grammar parser and string literal processing.
+"""
+
+# Map of escape sequences to their corresponding characters
+# Used for interpreting backslash escapes in string literals and grammar definitions
+SPECIAL_ESCAPED_MAP = {
+    'a': '\a',   # Bell
+    'b': '\b',   # Backspace
+    'f': '\f',   # Form feed
+    'n': '\n',   # Newline
+    'r': '\r',   # Carriage return
+    't': '\t',   # Tab
+    'v': '\v',   # Vertical tab
+    '\\': '\\',  # Backslash
+    '\n': '',    # Escaped newline (line continuation)
+    '"': '"',    # Double quote
+    "'": "'",    # Single quote
+}

simpleparse/common/iso_date.py

@@ -0,0 +1,153 @@
+"""Canonical ISO date format YYYY-MM-DDTHH:mm:SS+HH:mm
+
+This parser is _extremely_ strict, and the dates that match it,
+though really easy to work with for the computer, are not particularly
+readable.  See the iso_date_loose module for a slightly relaxed
+definition which allows the "T" character to be replaced by a
+" " character, and allows a space before the timezone offset, as well
+as allowing the integer values to use non-0-padded integers.
+
+
+    ISO_date -- YYYY-MM-DD format, with a month and date optional
+    ISO_time -- HH:mm:SS format, with minutes and seconds optional
+    ISO_date_time -- YYYY-MM-DD HH:mm:SS+HH:mm format,
+        with time optional and TimeZone offset optional
+
+Interpreter:
+    MxInterpreter
+        Interprets the parse tree as mx.DateTime values
+        ISO_date and ISO_time
+            returns DateTime objects
+        Time only
+            returns RelativeDateTime object which, when
+            added to a DateTime gives you the given time
+            within that day
+"""
+try:
+    from mx import DateTime
+    haveMX = 1
+except ImportError:
+    haveMX = 0
+from simpleparse.parser import Parser
+from simpleparse import common, objectgenerator
+from simpleparse.common import chartypes, numbers
+from simpleparse.dispatchprocessor import *
+
+c = {}
+
+declaration ="""
+year      := digit,digit,digit,digit
+month     := digit,digit
+day       := digit,digit
+
+hour      := digit,digit
+minute    := digit,digit
+second    := digit,digit
+offset_sign := [-+]
+offset    := offset_sign, hour, time_separator?, minute
+
+<date_separator> := '-'
+<time_separator> := ':'
+
+ISO_date   := year, (date_separator, month, (date_separator, day)?)?
+ISO_time   := hour, (time_separator, minute, (time_separator, second)?)?
+ISO_date_time  := ISO_date, ([T], ISO_time)?, offset?
+"""
+
+
+
+
+_p = Parser( declaration )
+for name in ["ISO_time","ISO_date", "ISO_date_time"]:
+    c[ name ] = objectgenerator.LibraryElement(
+        generator = _p._generator,
+        production = name,
+    )
+common.share( c )
+
+if haveMX:
+    class MxInterpreter(DispatchProcessor):
+        """Interpret a parsed ISO_date_time_loose in GMT/UTC time or localtime
+        """
+        def __init__(
+            self,
+            inputLocal = 1,
+            returnLocal = 1,
+        ):
+            self.inputLocal = inputLocal
+            self.returnLocal = returnLocal
+        dateName = 'ISO_date'
+        timeName = 'ISO_time'
+        def ISO_date_time( self, info, buffer):
+            """Interpret the loose ISO date + time format"""
+            (tag, left, right, sublist) = info
+            set = singleMap( sublist, self, buffer )
+            base, time, offset = (
+                set.get(self.dateName),
+                set.get(self.timeName) or DateTime.RelativeDateTime(hour=0,minute=0,second=0),
+                set.get( "offset" ),
+            )
+            base = base + time
+            offset = set.get( "offset" )
+            if offset is not None:
+                # an explicit timezone was entered, convert to gmt and return as appropriate...
+                gmt = base - offset
+                if self.returnLocal:
+                    return gmt.localtime()
+                else:
+                    return gmt
+            # was in the default input locale (either gmt or local)
+            if self.inputLocal and self.returnLocal:
+                return base
+            elif not self.inputLocal and not self.returnLocal:
+                return base
+            elif self.inputLocal and not self.returnLocal:
+                # return gmt from local...
+                return base.gmtime()
+            else:
+                return base.localtime()
+        def ISO_date( self, info, buffer):
+            """Interpret the ISO date format"""
+            (tag, left, right, sublist) = info
+            set = {}
+            for item in sublist:
+                set[ item[0] ] = dispatch( self, item, buffer)
+            return DateTime.DateTime(
+                set.get("year") or now().year,
+                set.get("month") or 1,
+                set.get("day") or 1,
+            )
+        def ISO_time( self, info, buffer):
+            """Interpret the ISO time format"""
+            (tag, left, right, sublist) = info
+            set = {}
+            for item in sublist:
+                set[ item[0] ] = dispatch( self, item, buffer)
+            return DateTime.RelativeDateTime(
+                hour = set.get("hour") or 0,
+                minute = set.get("minute") or 0,
+                second = set.get("second") or 0,
+            )
+
+        integer = numbers.IntInterpreter()
+        second =  offset_minute = offset_hour = year = month = day = hour =minute =integer
+        
+        def offset( self, info, buffer):
+            """Calculate the time zone offset as a date-time delta"""
+            (tag, left, right, sublist) = info
+            set = singleMap( sublist, self, buffer )
+            direction = set.get('offset_sign',1)
+            hour = set.get( "hour", 0)
+            minute = set.get( "minute", 0)
+            delta = DateTime.DateTimeDelta( 0, hour*direction, minute*direction)
+            return delta
+            
+        def offset_sign( self , info, buffer):
+            """Interpret the offset sign as a multiplier"""
+            (tag, left, right, sublist) = info
+            v = buffer [left: right]
+            if v in ' +':
+                return 1
+            else:
+                return -1
+