# $Id: statemachine.py 4564 2006-05-21 20:44:42Z wiemann $

# Author: David Goodger <goodger@python.org>

# Copyright: This module has been placed in the public domain.

"""

A finite state machine specialized for regular-expression-based text filters,

this module defines the following classes:

- `StateMachine`, a state machine

- `State`, a state superclass

- `StateMachineWS`, a whitespace-sensitive version of `StateMachine`

- `StateWS`, a state superclass for use with `StateMachineWS`

- `SearchStateMachine`, uses `re.search()` instead of `re.match()`

- `SearchStateMachineWS`, uses `re.search()` instead of `re.match()`

- `ViewList`, extends standard Python lists.

- `StringList`, string-specific ViewList.

Exception classes:

- `StateMachineError`

- `UnknownStateError`

- `DuplicateStateError`

- `UnknownTransitionError`

- `DuplicateTransitionError`

- `TransitionPatternNotFound`

- `TransitionMethodNotFound`

- `UnexpectedIndentationError`

- `TransitionCorrection`: Raised to switch to another transition.

- `StateCorrection`: Raised to switch to another state & transition.

Functions:

- `string2lines()`: split a multi-line string into a list of one-line strings

How To Use This Module

======================

(See the individual classes, methods, and attributes for details.)

1. Import it: ``import statemachine`` or ``from statemachine import ...``.

   You will also need to ``import re``.

2. Derive a subclass of `State` (or `StateWS`) for each state in your state

   machine::

       class MyState(statemachine.State):

   Within the state's class definition:

   a) Include a pattern for each transition, in `State.patterns`::

          patterns = {'atransition': r'pattern', ...}

   b) Include a list of initial transitions to be set up automatically, in

      `State.initial_transitions`::

          initial_transitions = ['atransition', ...]

   c) Define a method for each transition, with the same name as the

      transition pattern::

          def atransition(self, match, context, next_state):

              # do something

              result = [...]  # a list

              return context, next_state, result

              # context, next_state may be altered

      Transition methods may raise an `EOFError` to cut processing short.

   d) You may wish to override the `State.bof()` and/or `State.eof()` implicit

      transition methods, which handle the beginning- and end-of-file.

   e) In order to handle nested processing, you may wish to override the

      attributes `State.nested_sm` and/or `State.nested_sm_kwargs`.

      If you are using `StateWS` as a base class, in order to handle nested

      indented blocks, you may wish to:

      - override the attributes `StateWS.indent_sm`,

        `StateWS.indent_sm_kwargs`, `StateWS.known_indent_sm`, and/or

        `StateWS.known_indent_sm_kwargs`;

      - override the `StateWS.blank()` method; and/or

      - override or extend the `StateWS.indent()`, `StateWS.known_indent()`,

        and/or `StateWS.firstknown_indent()` methods.

3. Create a state machine object::

       sm = StateMachine(state_classes=[MyState, ...],

                         initial_state='MyState')

4. Obtain the input text, which needs to be converted into a tab-free list of

   one-line strings. For example, to read text from a file called

   'inputfile'::

       input_string = open('inputfile').read()

       input_lines = statemachine.string2lines(input_string)

5. Run the state machine on the input text and collect the results, a list::

       results = sm.run(input_lines)

6. Remove any lingering circular references::

       sm.unlink()

"""

__docformat__ = 'restructuredtext'

import sys

import re

import types

import unicodedata

class StateMachine:

    """

    A finite state machine for text filters using regular expressions.

    The input is provided in the form of a list of one-line strings (no

    newlines). States are subclasses of the `State` class. Transitions consist

    of regular expression patterns and transition methods, and are defined in

    each state.

    The state machine is started with the `run()` method, which returns the

    results of processing in a list.

    """

    def __init__(self, state_classes, initial_state, debug=0):

        """

        Initialize a `StateMachine` object; add state objects.

        Parameters:

        - `state_classes`: a list of `State` (sub)classes.

        - `initial_state`: a string, the class name of the initial state.

        - `debug`: a boolean; produce verbose output if true (nonzero).

        """

        self.input_lines = None

        """`StringList` of input lines (without newlines).

        Filled by `self.run()`."""

        self.input_offset = 0

        """Offset of `self.input_lines` from the beginning of the file."""

        self.line = None

        """Current input line."""

        self.line_offset = -1

        """Current input line offset from beginning of `self.input_lines`."""

        self.debug = debug

        """Debugging mode on/off."""

        self.initial_state = initial_state

        """The name of the initial state (key to `self.states`)."""

        self.current_state = initial_state

        """The name of the current state (key to `self.states`)."""

        self.states = {}

        """Mapping of {state_name: State_object}."""

        self.add_states(state_classes)

        self.observers = []

        """List of bound methods or functions to call whenever the current

        line changes.  Observers are called with one argument, ``self``.

        Cleared at the end of `run()`."""

    def unlink(self):

        """Remove circular references to objects no longer required."""

        for state in self.states.values():

            state.unlink()

        self.states = None

    def run(self, input_lines, input_offset=0, context=None,

            input_source=None):

        """

        Run the state machine on `input_lines`. Return results (a list).

        Reset `self.line_offset` and `self.current_state`. Run the

        beginning-of-file transition. Input one line at a time and check for a

        matching transition. If a match is found, call the transition method

        and possibly change the state. Store the context returned by the

        transition method to be passed on to the next transition matched.

        Accumulate the results returned by the transition methods in a list.

        Run the end-of-file transition. Finally, return the accumulated

        results.

        Parameters:

        - `input_lines`: a list of strings without newlines, or `StringList`.

        - `input_offset`: the line offset of `input_lines` from the beginning

          of the file.

        - `context`: application-specific storage.

        - `input_source`: name or path of source of `input_lines`.

        """

        self.runtime_init()

        if isinstance(input_lines, StringList):

            self.input_lines = input_lines

        else:

            self.input_lines = StringList(input_lines, source=input_source)

        self.input_offset = input_offset

        self.line_offset = -1

        self.current_state = self.initial_state

        if self.debug:

            print >>sys.stderr, (

                '\nStateMachine.run: input_lines (line_offset=%s):\n| %s'

                % (self.line_offset, '\n| '.join(self.input_lines)))

        transitions = None

        results = []

        state = self.get_state()

        try:

            if self.debug:

                print >>sys.stderr, ('\nStateMachine.run: bof transition')

            context, result = state.bof(context)

            results.extend(result)

            while 1:

                try:

                    try:

                        self.next_line()

                        if self.debug:

                            source, offset = self.input_lines.info(

                                self.line_offset)

                            print >>sys.stderr, (

                                '\nStateMachine.run: line (source=%r, '

                                'offset=%r):\n| %s'

                                % (source, offset, self.line))

                        context, next_state, result = self.check_line(

                            context, state, transitions)

                    except EOFError:

                        if self.debug:

                            print >>sys.stderr, (

                                '\nStateMachine.run: %s.eof transition'

                                % state.__class__.__name__)

                        result = state.eof(context)

                        results.extend(result)

                        break

                    else:

                        results.extend(result)

                except TransitionCorrection, exception:

                    self.previous_line() # back up for another try

                    transitions = (exception.args[0],)

                    if self.debug:

                        print >>sys.stderr, (

                              '\nStateMachine.run: TransitionCorrection to '

                              'state "%s", transition %s.'

                              % (state.__class__.__name__, transitions[0]))

                    continue

                except StateCorrection, exception:

                    self.previous_line() # back up for another try

                    next_state = exception.args[0]

                    if len(exception.args) == 1:

                        transitions = None

                    else:

                        transitions = (exception.args[1],)

                    if self.debug:

                        print >>sys.stderr, (

                              '\nStateMachine.run: StateCorrection to state '

                              '"%s", transition %s.'

                              % (next_state, transitions[0]))

                else:

                    transitions = None

                state = self.get_state(next_state)

        except:

            if self.debug:

                self.error()

            raise

        self.observers = []

        return results

    def get_state(self, next_state=None):

        """

        Return current state object; set it first if `next_state` given.

        Parameter `next_state`: a string, the name of the next state.

        Exception: `UnknownStateError` raised if `next_state` unknown.

        """

        if next_state:

            if self.debug and next_state != self.current_state:

                print >>sys.stderr, \

                      ('\nStateMachine.get_state: Changing state from '

                       '"%s" to "%s" (input line %s).'

                       % (self.current_state, next_state,

                          self.abs_line_number()))

            self.current_state = next_state

        try:

            return self.states[self.current_state]

        except KeyError:

            raise UnknownStateError(self.current_state)

    def next_line(self, n=1):

        """Load `self.line` with the `n`'th next line and return it."""

        try:

            try:

                self.line_offset += n

                self.line = self.input_lines[self.line_offset]

            except IndexError:

                self.line = None

                raise EOFError

            return self.line

        finally:

            self.notify_observers()

    def is_next_line_blank(self):

        """Return 1 if the next line is blank or non-existant."""

        try:

            return not self.input_lines[self.line_offset + 1].strip()

        except IndexError:

            return 1

    def at_eof(self):

        """Return 1 if the input is at or past end-of-file."""

        return self.line_offset >= len(self.input_lines) - 1

    def at_bof(self):

        """Return 1 if the input is at or before beginning-of-file."""

        return self.line_offset <= 0

    def previous_line(self, n=1):

        """Load `self.line` with the `n`'th previous line and return it."""

        self.line_offset -= n

        if self.line_offset < 0:

            self.line = None

        else:

            self.line = self.input_lines[self.line_offset]

        self.notify_observers()

        return self.line

    def goto_line(self, line_offset):

        """Jump to absolute line offset `line_offset`, load and return it."""

        try:

            try:

                self.line_offset = line_offset - self.input_offset

                self.line = self.input_lines[self.line_offset]

            except IndexError:

                self.line = None

                raise EOFError

            return self.line

        finally:

            self.notify_observers()

    def get_source(self, line_offset):

        """Return source of line at absolute line offset `line_offset`."""

        return self.input_lines.source(line_offset - self.input_offset)

    def abs_line_offset(self):

        """Return line offset of current line, from beginning of file."""

        return self.line_offset + self.input_offset

    def abs_line_number(self):

        """Return line number of current line (counting from 1)."""

        return self.line_offset + self.input_offset + 1

    def insert_input(self, input_lines, source):

        self.input_lines.insert(self.line_offset + 1, '',

                                source='internal padding')

        self.input_lines.insert(self.line_offset + 1, '',

                                source='internal padding')

        self.input_lines.insert(self.line_offset + 2,

                                StringList(input_lines, source))

    def get_text_block(self, flush_left=0):

        """

        Return a contiguous block of text.

        If `flush_left` is true, raise `UnexpectedIndentationError` if an

        indented line is encountered before the text block ends (with a blank

        line).

        """

        try:

            block = self.input_lines.get_text_block(self.line_offset,

                                                    flush_left)

            self.next_line(len(block) - 1)

            return block

        except UnexpectedIndentationError, error:

            block, source, lineno = error

            self.next_line(len(block) - 1) # advance to last line of block

            raise

    def check_line(self, context, state, transitions=None):

        """

        Examine one line of input for a transition match & execute its method.

        Parameters:

        - `context`: application-dependent storage.

        - `state`: a `State` object, the current state.

        - `transitions`: an optional ordered list of transition names to try,

          instead of ``state.transition_order``.

        Return the values returned by the transition method:

        - context: possibly modified from the parameter `context`;

        - next state name (`State` subclass name);

        - the result output of the transition, a list.

        When there is no match, ``state.no_match()`` is called and its return

        value is returned.

        """

        if transitions is None:

            transitions =  state.transition_order

        state_correction = None

        if self.debug:

            print >>sys.stderr, (

                  '\nStateMachine.check_line: state="%s", transitions=%r.'

                  % (state.__class__.__name__, transitions))

        for name in transitions:

            pattern, method, next_state = state.transitions[name]

            match = self.match(pattern)

            if match:

                if self.debug:

                    print >>sys.stderr, (

                          '\nStateMachine.check_line: Matched transition '

                          '"%s" in state "%s".'

                          % (name, state.__class__.__name__))

                return method(match, context, next_state)

        else:

            if self.debug:

                print >>sys.stderr, (

                      '\nStateMachine.check_line: No match in state "%s".'

                      % state.__class__.__name__)

            return state.no_match(context, transitions)

    def match(self, pattern):

        """

        Return the result of a regular expression match.

        Parameter `pattern`: an `re` compiled regular expression.

        """

        return pattern.match(self.line)

    def add_state(self, state_class):

        """

        Initialize & add a `state_class` (`State` subclass) object.

        Exception: `DuplicateStateError` raised if `state_class` was already

        added.

        """

        statename = state_class.__name__

        if self.states.has_key(statename):

            raise DuplicateStateError(statename)

        self.states[statename] = state_class(self, self.debug)

    def add_states(self, state_classes):

        """

        Add `state_classes` (a list of `State` subclasses).

        """

        for state_class in state_classes:

            self.add_state(state_class)

    def runtime_init(self):

        """

        Initialize `self.states`.

        """

        for state in self.states.values():

            state.runtime_init()

    def error(self):

        """Report error details."""

        type, value, module, line, function = _exception_data()

        print >>sys.stderr, '%s: %s' % (type, value)

        print >>sys.stderr, 'input line %s' % (self.abs_line_number())

        print >>sys.stderr, ('module %s, line %s, function %s'

                             % (module, line, function))

    def attach_observer(self, observer):

        """

        The `observer` parameter is a function or bound method which takes two

        arguments, the source and offset of the current line.

        """

        self.observers.append(observer)

    def detach_observer(self, observer):

        self.observers.remove(observer)

    def notify_observers(self):

        for observer in self.observers:

            try:

                info = self.input_lines.info(self.line_offset)

            except IndexError:

                info = (None, None)

            observer(*info)

class State:

    """

    State superclass. Contains a list of transitions, and transition methods.

    Transition methods all have the same signature. They take 3 parameters:

    - An `re` match object. ``match.string`` contains the matched input line,

      ``match.start()`` gives the start index of the match, and

      ``match.end()`` gives the end index.

    - A context object, whose meaning is application-defined (initial value

      ``None``). It can be used to store any information required by the state

      machine, and the retured context is passed on to the next transition

      method unchanged.

    - The name of the next state, a string, taken from the transitions list;

      normally it is returned unchanged, but it may be altered by the

      transition method if necessary.

    Transition methods all return a 3-tuple:

    - A context object, as (potentially) modified by the transition method.

    - The next state name (a return value of ``None`` means no state change).

    - The processing result, a list, which is accumulated by the state

      machine.

    Transition methods may raise an `EOFError` to cut processing short.

    There are two implicit transitions, and corresponding transition methods

    are defined: `bof()` handles the beginning-of-file, and `eof()` handles

    the end-of-file. These methods have non-standard signatures and return

    values. `bof()` returns the initial context and results, and may be used

    to return a header string, or do any other processing needed. `eof()`

    should handle any remaining context and wrap things up; it returns the

    final processing result.

    Typical applications need only subclass `State` (or a subclass), set the

    `patterns` and `initial_transitions` class attributes, and provide

    corresponding transition methods. The default object initialization will

    take care of constructing the list of transitions.

    """