File: //opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyc
�
�d�Oc @ s d Z d Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d f d � � YZ
d f d � � YZ d
e
f d � � YZ d e f d
� � YZ
d f d � � YZ d e e
f d � � YZ d e e f d � � YZ d f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d � � YZ d e f d! � � YZ d" e f d# � � YZ d$ e f d% � � YZ d& e f d' � � YZ d( e f d) � � YZ d* e f d+ � � YZ d, e e j d- � d. � Z d/ � Z! d S(0 s
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()
t restructuredtexti����N( t utils( t ErrorOutputt StateMachinec B s e Z d Z e d � Z d � Z d d d d d � Z d d � Z d d � Z d � Z
d � Z d
� Z d d � Z
d � Z d
� Z d � Z d � Z d d � Z d � Z e d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z RS( s�
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.
c C sn d | _ d | _ d | _ d | _ | | _ | | _ | | _ i | _ | j | � g | _
t � | _ d S( s+
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).
i i����N(
t Nonet input_linest input_offsett linet line_offsett debugt
initial_statet
current_statet statest
add_statest observersR t _stderr( t selft
state_classesR
R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __init__� s
c C s1 x! | j j � D] } | j � q Wd | _ d S( s9 Remove circular references to objects no longer required.N( R t valuest unlinkR ( R t state( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR � s i c C s� | j � t | t � r% | | _ n t | d | �| _ | | _ d | _ | pX | j | _ | j r� | j d | j d j
| j � f IJn d } g } | j � } y| j r� | j d IJn | j
| � \ } } | j | � x�t r�y� yp | j � | j rC| j j | j � \ }
} | j d |
| | j f IJn | j | | | � \ } } } WnQ t k
r�| j r�| j d | j j IJn | j | � } | j | � Pn X| j | � Wn� t k
r#}
| j � |
j d f } | j r� | j d | j j | d f IJq� q� n� t k
r�}
| j � |
j d } t |
j � d
k rgd } n |
j d
f } | j r�| j d | | d f IJq�n Xd } | j | � } q� WWn | j r�| j � n � n Xg | _ | S(
s�
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`.
- `initial_state`: name of initial state.
t sourcei����u5
StateMachine.run: input_lines (line_offset=%s):
| %su
| s!
StateMachine.run: bof transitionu4
StateMachine.run: line (source=%r, offset=%r):
| %ss$
StateMachine.run: %s.eof transitioni sE
StateMachine.run: TransitionCorrection to state "%s", transition %s.i s@
StateMachine.run: StateCorrection to state "%s", transition %s.N( t runtime_initt
isinstancet
StringListR R R R
R R R t joinR t get_statet boft extendt Truet next_linet infoR t
check_linet EOFErrort __class__t __name__t eoft TransitionCorrectiont
previous_linet argst StateCorrectiont lent errorR ( R R R t contextt input_sourceR
t transitionst resultsR t resultR t offsett
next_statet exception( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt run� s�
c C s� | rP | j rD | | j k rD | j d | j | | j � f IJn | | _ n y | j | j SWn t k
r� t | j � � n Xd S( s�
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.
sJ
StateMachine.get_state: Changing state from "%s" to "%s" (input line %s).N( R R R t abs_line_numberR t KeyErrort UnknownStateError( R R2 ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR s
i c C sf zT y& | j | 7_ | j | j | _ Wn t k
rK d | _ t � n X| j SWd | j � Xd S( s9 Load `self.line` with the `n`'th next line and return it.N( R R R t
IndexErrorR R" t notify_observers( R t n( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR . s
c C s6 y | j | j d j � SWn t k
r1 d SXd S( s3 Return 1 if the next line is blank or non-existant.i N( R R t stripR8 ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt is_next_line_blank; s
c C s | j t | j � d k S( s0 Return 1 if the input is at or past end-of-file.i ( R R* R ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt at_eofB s c C s
| j d k S( s8 Return 1 if the input is at or before beginning-of-file.i ( R ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt at_bofF s c C sN | j | 8_ | j d k r* d | _ n | j | j | _ | j � | j S( s= Load `self.line` with the `n`'th previous line and return it.i N( R R R R R9 ( R R: ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR' J s
c C sg zU y' | | j | _ | j | j | _ Wn t k
rL d | _ t � n X| j SWd | j � Xd S( s? Jump to absolute line offset `line_offset`, load and return it.N( R R R R R8 R R" R9 ( R R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt goto_lineT s
c C s | j j | | j � S( s< Return source of line at absolute line offset `line_offset`.( R R R ( R R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt
get_sourcea s c C s | j | j S( s; Return line offset of current line, from beginning of file.( R R ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt abs_line_offsete s c C s | j | j d S( s5 Return line number of current line (counting from 1).i ( R R ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR5 i s c C s� | d k r | j } n | | j d } y& | j j | � \ } } | d } WnT t k
r� | j | | j � \ } } | | d f St k
r� d \ } } n X| | f S( s\ Return (source, line) tuple for current or given line number.
Looks up the source and line number in the `self.input_lines`
StringList instance to count for included source files.
If the optional argument `lineno` is given, convert it from an
absolute line number to the corresponding (source, line) pair.
i N( NN( R R R R R t TypeErrort get_source_and_lineR8 ( R t linenoR1 t srct srcoffsett srcline( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRC m s
c C s� | j j | j d d d d | d t | � �| j j | j d d d d | d d �| j j | j d t | | � � d S( Ni t R s internal padding after R1 s internal padding before i����i ( R t insertR R* R ( R R R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt insert_input� s
c C sx y7 | j j | j | � } | j t | � d � | SWn: t k
rs } | j d } | j t | � d � � n Xd S( s�
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).
i i N( R t get_text_blockR R R* t UnexpectedIndentationErrorR( ( R t
flush_leftt blockt err( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRK � s
c
C s� | d k r | j } n d } | j rG | j d | j j | f IJn x� | D]m } | j | \ } } } | j | j � } | rN | j r� | j d | | j j f IJn | | | | � SqN W| j r� | j d | j j IJn | j | | � Sd S( s�
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.
s5
StateMachine.check_line: state="%s", transitions=%r.s@
StateMachine.check_line: Matched transition "%s" in state "%s".s1
StateMachine.check_line: No match in state "%s".N(
R t transition_orderR R R# R$ R. t matchR t no_match(
R R, R R. t state_correctiont namet patternt methodR2 RQ ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR! � s*
c C sD | j } | | j k r' t | � � n | | | j � | j | <d S( s�
Initialize & add a `state_class` (`State` subclass) object.
Exception: `DuplicateStateError` raised if `state_class` was already
added.
N( R$ R t DuplicateStateErrorR ( R t state_classt statename( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt add_state� s c C s" x | D] } | j | � q Wd S( sE
Add `state_classes` (a list of `State` subclasses).
N( RZ ( R R RX ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR
� s
c C s( x! | j j � D] } | j � q Wd S( s+
Initialize `self.states`.
N( R R R ( R R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR � s c C sd t � \ } } } } } | j d | | f IJ| j d | j � IJ| j d | | | f IJd S( s Report error details.u %s: %ss
input line %su module %s, line %s, function %sN( t _exception_dataR R5 ( R t typet valuet moduleR t function( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR+ � s
c C s | j j | � d S( s�
The `observer` parameter is a function or bound method which takes two
arguments, the source and offset of the current line.
N( R t append( R t observer( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt attach_observer� s c C s | j j | � d S( N( R t remove( R Ra ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt detach_observer� s c C sU xN | j D]C } y | j j | j � } Wn t k
rB d } n X| | � q
Wd S( N( NN( R R R R R8 R ( R Ra R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR9 s
N( R$ t
__module__t __doc__t FalseR R R R4 R R R< R= R> R' R? R@ RA R5 RC RJ RK R! RZ R
R R+ Rb Rd R9 ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR u s4 / `
, t Statec B s� e Z d Z d Z d Z d Z d Z e d � Z d � Z
d � Z d � Z d � Z
d � Z d � Z d d � Z d � Z d
� Z d � Z d � Z d
� Z RS( sv
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.
c C s� g | _ i | _ | j � | | _ | | _ | j d k rO | j j | _ n | j d k r� i | j g d 6| j j d 6| _ n d S( s�
Initialize a `State` object; make & add initial transitions.
Parameters:
- `statemachine`: the controlling `StateMachine` object.
- `debug`: a boolean; produce verbose output if true.
R R
N(
RP R. t add_initial_transitionst
state_machineR t nested_smR R# t nested_sm_kwargsR$ ( R Rj R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR V s
c C s d S( s{
Initialize this `State` before running the state machine; called from
`self.state_machine.run()`.
N( ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR z s c C s
d | _ d S( s9 Remove circular references to objects no longer required.N( R Rj ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR � s c C s8 | j r4 | j | j � \ } } | j | | � n d S( s> Make and add transitions listed in `self.initial_transitions`.N( t initial_transitionst make_transitionst add_transitions( R t namesR. ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRi � s c C sk xG | D]? } | | j k r+ t | � � n | | k r t | � � q q W| | j d *| j j | � d S( s"
Add a list of transitions to the start of the transition list.
Parameters:
- `names`: a list of transition names.
- `transitions`: a mapping of names to transition tuples.
Exceptions: `DuplicateTransitionError`, `UnknownTransitionError`.
i N( R. t DuplicateTransitionErrort UnknownTransitionErrorRP t update( R Rp R. RT ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRo � s
c C s? | | j k r t | � � n | g | j d *| | j | <d S( s�
Add a transition to the start of the transition list.
Parameter `transition`: a ready-made transition 3-tuple.
Exception: `DuplicateTransitionError`.
i N( R. Rq RP ( R RT t
transition( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt add_transition� s c C s8 y | j | =| j j | � Wn t | � � n Xd S( s^
Remove a transition by `name`.
Exception: `UnknownTransitionError`.
N( R. RP Rc Rr ( R RT ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt remove_transition� s
c C s� | d k r | j j } n y2 | j | } t | d � sL t j | � } n Wn- t k
r| t d | j j | f � � n Xy t | | � } Wn- t
k
r� t d | j j | f � � n X| | | f S( s�
Make & return a transition tuple based on `name`.
This is a convenience function to simplify transition creation.
Parameters:
- `name`: a string, the name of the transition pattern & method. This
`State` object must have a method called '`name`', and a dictionary
`self.patterns` containing a key '`name`'.
- `next_state`: a string, the name of the next `State` object for this
transition. A value of ``None`` (or absent) implies no state change
(i.e., continue with the same state).
Exceptions: `TransitionPatternNotFound`, `TransitionMethodNotFound`.
RQ s %s.patterns[%r]s %s.%sN( R R# R$ t patternst hasattrt ret compileR6 t TransitionPatternNotFoundt getattrt AttributeErrort TransitionMethodNotFound( R RT R2 RU RV ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt make_transition� s
c C s� t d � } g } i } xk | D]c } t | � | k rZ | j | � | | <| j | � q | j | � | | d <| j | d � q W| | f S( s�
Return a list of transition names and a transition mapping.
Parameter `name_list`: a list, where each entry is either a transition
name string, or a 1- or 2-tuple (transition name, optional next state
name).
RH i ( R\ R R` ( R t name_listt
stringtypeRp R. t namestate( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRn � s
c C s
| d g f S( s'
Called when there is no match from `StateMachine.check_line()`.
Return the same values returned by transition methods:
- context: unchanged;
- next state name: ``None``;
- empty result list.
Override in subclasses to catch this event.
N( R ( R R, R. ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRR � s c C s
| g f S( s�
Handle beginning-of-file. Return unchanged `context`, empty result.
Override in subclasses.
Parameter `context`: application-defined storage.
( ( R R, ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR � s c C s g S( s�
Handle end-of-file. Return empty result.
Override in subclasses.
Parameter `context`: application-defined storage.
( ( R R, ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR% s c C s
| | g f S( s�
A "do nothing" transition method.
Return unchanged `context` & `next_state`, empty result. Useful for
simple state changes (actionless transitions).
( ( R RQ R, R2 ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt nop s N( R$ Re Rf R Rw Rm Rk Rl Rg R R R Ri Ro Ru Rv R Rn RR R R% R� ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRh s$ ' $
!
t StateMachineWSc B s> e Z d Z e e d � Z e e d � Z e e e d � Z RS( sq
`StateMachine` subclass specialized for whitespace recognition.
There are three methods provided for extracting indented text blocks:
- `get_indented()`: use when the indent is unknown.
- `get_known_indented()`: use when the indent is known for all lines.
- `get_first_known_indented()`: use when only the first line's indent is
known.
c C s� | j � } | j j | j | | � \ } } } | rP | j t | � d � n x/ | r� | d j � r� | j � | d 7} qS W| | | | f S( s
Return a block of indented lines of text, and info.
Extract an indented block where the indent is unknown for all lines.
:Parameters:
- `until_blank`: Stop collecting at the first blank line if true.
- `strip_indent`: Strip common leading indent if true (default).
:Return:
- the indented block (a list of lines of text),
- its indent,
- its first line offset from BOF, and
- whether or not it finished with a blank line.
i i ( RA R t get_indentedR R R* R; t
trim_start( R t until_blankt strip_indentR1 t indentedt indentt blank_finish( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� & s
c C s� | j � } | j j | j | | d | �\ } } } | j t | � d � x/ | r~ | d j � r~ | j � | d 7} qP W| | | f S( s�
Return an indented block and info.
Extract an indented block where the indent is known for all lines.
Starting with the current line, extract the entire text block with at
least `indent` indentation (which must be whitespace, except for the
first line).
:Parameters:
- `indent`: The number of indent columns/characters.
- `until_blank`: Stop collecting at the first blank line if true.
- `strip_indent`: Strip `indent` characters of indentation if true
(default).
:Return:
- the indented block,
- its first line offset from BOF, and
- whether or not it finished with a blank line.
t block_indenti i ( RA R R� R R R* R; R� ( R R� R� R� R1 R� R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt get_known_indented@ s
c C s� | j � } | j j | j | | d | �\ } } } | j t | � d � | r� x2 | r� | d j � r� | j � | d 7} qV Wn | | | | f S( s�
Return an indented block and info.
Extract an indented block where the indent is known for the first line
and unknown for all other lines.
:Parameters:
- `indent`: The first line's indent (# of columns/characters).
- `until_blank`: Stop collecting at the first blank line if true
(1).
- `strip_indent`: Strip `indent` characters of indentation if true
(1, default).
- `strip_top`: Strip blank lines from the beginning of the block.
:Return:
- the indented block,
- its indent,
- its first line offset from BOF, and
- whether or not it finished with a blank line.
t first_indenti i ( RA R R� R R R* R; R� ( R R� R� R� t strip_topR1 R� R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt get_first_known_indented^ s
( R$ Re Rf Rg R R� R� R� ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� s
t StateWSc B sy e Z d Z d Z d Z d Z d Z i d d 6d d 6Z d Z e
d � Z d � Z d � Z
d � Z d � Z d
� Z RS(
s�
State superclass specialized for whitespace (blank lines & indents).
Use this class with `StateMachineWS`. The transitions 'blank' (for blank
lines) and 'indent' (for indented text blocks) are added automatically,
before any other transitions. The transition method `blank()` handles
blank lines and `indent()` handles nested indented blocks. Indented
blocks trigger a new state machine to be created by `indent()` and run.
The class of the state machine to be created is in `indent_sm`, and the
constructor keyword arguments are in the dictionary `indent_sm_kwargs`.
The methods `known_indent()` and `firstknown_indent()` are provided for
indented blocks where the indent (all lines' and first line's only,
respectively) is known to the transition method, along with the attributes
`known_indent_sm` and `known_indent_sm_kwargs`. Neither transition method
is triggered automatically.
s *$t blanks +R� c C s� t j | | | � | j d k r1 | j | _ n | j d k rO | j | _ n | j d k rm | j | _ n | j d k r� | j | _ n d S( s�
Initialize a `StateSM` object; extends `State.__init__()`.
Check for indent state machine attributes, set defaults if not set.
N( Rh R t indent_smR Rk t indent_sm_kwargsRl t known_indent_smt known_indent_sm_kwargs( R Rj R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR � s c C sg t j | � | j d k r( i | _ n | j j | j � | j | j � \ } } | j | | � d S( s�
Add whitespace-specific transitions before those defined in subclass.
Extends `State.add_initial_transitions()`.
N( Rh Ri Rw R Rs t ws_patternsRn t ws_initial_transitionsRo ( R Rp R. ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRi � s
c C s | j | | | � S( s9 Handle blank lines. Does nothing. Override in subclasses.( R� ( R RQ R, R2 ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s c
C sX | j j � \ } } } } | j d | j | j � } | j | d | �} | | | f S( s�
Handle an indented text block. Extend or override in subclasses.
Recursively run the registered state machine for indented blocks
(`self.indent_sm`).
R R ( Rj R� R� R R� R4 (
R RQ R, R2 R� R� R R� t smR/ ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s c C s^ | j j | j � � \ } } } | j d | j | j � } | j | d | �} | | | f S( s
Handle a known-indent text block. Extend or override in subclasses.
Recursively run the registered state machine for known-indent indented
blocks (`self.known_indent_sm`). The indent is the length of the
match, ``match.end()``.
R R ( Rj R� t endR� R R� R4 ( R RQ R, R2 R� R R� R� R/ ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt known_indent� s
! c C s^ | j j | j � � \ } } } | j d | j | j � } | j | d | �} | | | f S( s0
Handle an indented text block (first line's indent known).
Extend or override in subclasses.
Recursively run the registered state machine for known-indent indented
blocks (`self.known_indent_sm`). The indent is the length of the
match, ``match.end()``.
R R ( Rj R� R� R� R R� R4 ( R RQ R, R2 R� R R� R� R/ ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt first_known_indent� s
! N( R� R� ( R$ Re Rf R R� R� R� R� R� R� Rg R Ri R� R� R� R� ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s
t _SearchOverridec B s e Z d Z d � Z RS( s�
Mix-in class to override `StateMachine` regular expression behavior.
Changes regular expression matching, from the default `re.match()`
(succeeds only if the pattern matches at the start of `self.line`) to
`re.search()` (succeeds if the pattern matches anywhere in `self.line`).
When subclassing a `StateMachine`, list this class **first** in the
inheritance list of the class definition.
c C s | j | j � S( s�
Return the result of a regular expression search.
Overrides `StateMachine.match()`.
Parameter `pattern`: `re` compiled regular expression.
( t searchR ( R RU ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRQ s ( R$ Re Rf RQ ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR�
s
t SearchStateMachinec B s e Z d Z RS( s@ `StateMachine` which uses `re.search()` instead of `re.match()`.( R$ Re Rf ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� $ s t SearchStateMachineWSc B s e Z d Z RS( sB `StateMachineWS` which uses `re.search()` instead of `re.match()`.( R$ Re Rf ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� ) s t ViewListc B s� e Z d Z d* d* d* d* d* d � Z d � Z d � Z d � Z d � Z d � Z d � Z
d � Z d � Z d
� Z
d � Z d � Z d
� Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z e Z d � Z d � Z d* d d � Z d* d d � Z d d � Z d d � Z d d � Z d � Z d � Z! d! � Z" d" � Z# d# � Z$ d$ � Z% d% � Z& d& � Z' d' � Z( d( � Z) d) � Z* RS(+ s>
List with extended functionality: slices of ViewList objects are child
lists, linked to their parents. Changes made to a child list also affect
the parent list. A child list is effectively a "view" (in the SQL sense)
of the parent list. Changes to parent lists, however, do *not* affect
active child lists. If a parent list is changed, any active child lists
should be recreated.
The start and end of the slice can be trimmed using the `trim_start()` and
`trim_end()` methods, without affecting the parent list. The link between
child and parent lists can be broken by calling `disconnect()` on the
child list.
Also, ViewList objects keep track of the source & offset of each item.
This information is accessible via the `source()`, `offset()`, and
`info()` methods.
c C s� g | _ g | _ | | _ | | _ t | t � rP | j | _ | j | _ n^ | d k r� t | � | _ | r} | | _ q� g t t | � � D] } | | f ^ q� | _ n t | j � t | j � k s� t
d � � d S( Ns
data mismatch( t datat itemst parentt
parent_offsetR R� R t listt rangeR* t AssertionError( R t initlistR R� R� R� t i( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR B s
1c C s
t | j � S( N( t strR� ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __str__] s c C s d | j j | j | j f S( Ns %s(%s, items=%s)( R# R$ R� R� ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __repr__` s c C s | j | j | � k S( N( R� t _ViewList__cast( R t other( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __lt__d RH c C s | j | j | � k S( N( R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __le__e RH c C s | j | j | � k S( N( R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __eq__f RH c C s | j | j | � k S( N( R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __ne__g RH c C s | j | j | � k S( N( R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __gt__h RH c C s | j | j | � k S( N( R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __ge__i RH c C s t | j | j | � � S( N( t cmpR� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __cmp__j RH c C s t | t � r | j S| Sd S( N( R R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __castl s c C s
| | j k S( N( R� ( R t item( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __contains__r RH c C s
t | j � S( N( R* R� ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __len__s RH c C s� t | t j � ru | j d k s- t d � � | j | j | j | j !d | j
| j | j !d | d | j pq d �S| j | Sd S( Ni s cannot handle slice with strideR� R� R� i ( Ni ( R t typest SliceTypet stepR R� R# R� t startt stopR� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __getitem__y s c C s t | t j � r� | j d k s- t d � � t | t � sK t d � � n | j | j | j | j
+| j | j | j | j
+t | j � t | j � k s� t d � � | j
r| | j
| j p� d | j | j
p� t | � | j +qn- | | j | <| j
r| | j
| | j <n d S( Ni s cannot handle slice with strides( assigning non-ViewList to ViewList slices
data mismatchi ( Ni ( R R� R� R� R R� R� RB R� R� R� R� R* R� R� ( R R� R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __setitem__� s * <
c C s� y5 | j | =| j | =| j r4 | j | | j =n Wn� t k
r� | j d k s` t d � � | j | j | j 5| j | j | j 5| j r� | j | j p� d | j | j p� t
| � | j 5q� n Xd S( Ns cannot handle slice with stridei ( R� R� R� R� RB R� R R� R� R� R* ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __delitem__� s
c C sF t | t � r6 | j | j | j d | j | j �St d � � d S( NR� s! adding non-ViewList to a ViewList( R R� R# R� R� RB ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __add__� s c C sF t | t � r6 | j | j | j d | j | j �St d � � d S( NR� s! adding ViewList to a non-ViewList( R R� R# R� R� RB ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __radd__� s c C s4 t | t � r$ | j | j 7_ n t d � � | S( Ns! argument to += must be a ViewList( R R� R� RB ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __iadd__� s c C s! | j | j | d | j | �S( NR� ( R# R� R� ( R R: ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __mul__� s c C s" | j | 9_ | j | 9_ | S( N( R� R� ( R R: ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt __imul__� s c C sw t | t � s t d � � n | j rM | j j t | j � | j | � n | j j | j � | j j | j � d S( Ns( extending a ViewList with a non-ViewList(
R R� RB R� RI R* R� R� R R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR � s &i c C s{ | d k r | j | � n[ | j rQ | j j t | j � | j | | | � n | j j | � | j j | | f � d S( N( R R R� RI R* R� R� R` R� ( R R� R R1 ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR` � s
c C s | d k r� t | t � s* t d � � n | j | j | | +| j | j | | +| j rt | j � | t | j � } | j j | | j | � qnx | j j | | � | j j | | | f � | j rt | j � | t | j � } | j j | | j | | | � n d S( Ns+ inserting non-ViewList with no source given(
R R R� RB R� R� R� R* RI R� ( R R� R� R R1 t index( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRI � s i����c C sc | j rC t | j � | t | j � } | j j | | j � n | j j | � | j j | � S( N( R� R* R� t popR� R� ( R R� R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s
i c C s� | t | j � k r7 t d | t | j � f � � n | d k rR t d � � n | j | 4| j | 4| j r� | j | 7_ n d S( sW
Remove items from the start of the list, without touching the parent.
sC Size of trim too large; can't trim %s items from a list of size %s.i s Trim size must be >= 0.N( R* R� R8 R� R� R� ( R R: ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s
c C sl | t | j � k r7 t d | t | j � f � � n | d k rR t d � � n | j | 3| j | 3d S( sU
Remove items from the end of the list, without touching the parent.
sC Size of trim too large; can't trim %s items from a list of size %s.i s Trim size must be >= 0.N( R* R� R8 R� ( R R: ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt trim_end� s c C s | j | � } | | =d S( N( R� ( R R� R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRc s c C s | j j | � S( N( R� t count( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� RH c C s | j j | � S( N( R� R� ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� RH c C s' | j j � | j j � d | _ d S( N( R� t reverseR� R R� ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR�
s
c G so t | j | j � } | j | � g | D] } | d ^ q) | _ g | D] } | d ^ qI | _ d | _ d S( Ni i ( t zipR� R� t sortR R� ( R R( t tmpt entry( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� s
c C sX y | j | SWnB t k
rS | t | j � k rM | j | d d d f S� n Xd S( s% Return source & offset for index `i`.i i N( R� R8 R* R� R ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR s
c C s | j | � d S( s Return source for index `i`.i ( R ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR s c C s | j | � d S( s Return offset for index `i`.i ( R ( R R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR1 $ s c C s
d | _ d S( s- Break link between this list and parent list.N( R R� ( R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt
disconnect( s c c s> x7 t | j | j � D] \ } \ } } | | | f Vq Wd S( s8 Return iterator yielding (source, offset, value) tuples.N( R� R� R� ( R R] R R1 ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt xitems, s (c C s$ x | j � D] } d | GHq
Wd S( s= Print the list in `grep` format (`source:offset:value` lines)s %s:%d:%sN( R� ( R R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt pprint1 s N(+ R$ Re Rf R R R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� R� t __rmul__R� R R` RI R� R� R� Rc R� R� R� R� R R R1 R� R� R� ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� . sR
R c B sb e Z d Z d e j d � Z e d � Z d e e d d d � Z
e d � Z d � Z d � Z
RS( s* A `ViewList` with string-specific methods.i c C s5 g | j | | !D] } | | ^ q | j | | +d S( s�
Trim `length` characters off the beginning of each item, in-place,
from index `start` to `end`. No whitespace-checking is done on the
trimmed text. Does not affect slice parent.
N( R� ( R t lengthR� R� R ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt trim_left; s c C s� | } t | j � } x� | | k r� | j | } | j � sA Pn | r� | d d k r� | j | � \ } } t | | | !| | d � � n | d 7} q W| | | !S( s�
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).
i t i ( R* R� R; R RL ( R R� RM R� t lastR R R1 ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRK D s
c C s� | } | } | d k r- | d k r- | } n | d k rF | d 7} n t | j � } x� | | k rF| j | } | r� | d d k s� | d k r� | | j � r� | | k o� | j | d j � }
Pn | j � } | s� | r9d }
Pq9nI | d k r9t | � t | � } | d k r'| } q9t | | � } n | d 7} qX Wd }
| | | !}
| d k r�|
r�|
j d | |
j d <n | r�| r�|
j | d | d k �n |
| p�d |
f S( s�
Extract and return a StringList of indented lines of text.
Collect all lines with indentation, determine the minimum indentation,
remove the minimum indentation from all indented lines (unless
`strip_indent` is false), and return them. All lines up to but not
including the first unindented line will be returned.
:Parameters:
- `start`: The index of the first line to examine.
- `until_blank`: Stop collecting at the first blank line if true.
- `strip_indent`: Strip common leading indent if true (default).
- `block_indent`: The indent of the entire block, if known.
- `first_indent`: The indent of the first line, if known.
:Return:
- a StringList of indented lines with mininum indent removed;
- the amount of the indent;
- a boolean: did the indented block finish with a blank line or EOF?
i i R� R� N( R R* R� R; t lstript minR� ( R R� R� R� R� R� R� R� R� R R� t strippedt line_indentRN ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� Y sB
c C sn | | | !} | } x t t | j � � D]� } t j | j | � } y | | } Wn2 t k
r� | t | j | � t | � 7} n Xy | | } Wn2 t k
r� | t | j | � t | � 7} n X| j | | | !j � | j | <}
|
r) t | t |
� t |
j � � � } q) q) W| rjd | k o?| k n rjg | j D] }
|
| ^ qN| _ n | S( Ni ( R� R* R� R t column_indicesR8 t rstripR� R� ( R t topt leftt bottomt rightR� RN R� R� t ciR ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt get_2D_block� s$
%
%%,"&c C s� t t d � r t j } n d Sx� t t | j � � D]� } | j | } t | t � r5 g } x= | D]5 } | j | � | | � d k rd | j | � qd qd Wd j | � | j | <q5 q5 Wd S( s�
Pad all double-width characters in self by appending `pad_char` to each.
For East Asian language support.
t east_asian_widthNt WFRH (
Rx t unicodedataR� R� R* R� R t unicodeR` R ( R t pad_charR� R� R t newt char( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt pad_double_width� s
c C sD x= t t | j � � D]& } | j | j | | � | j | <q Wd S( s6 Replace all occurrences of substring `old` with `new`.N( R� R* R� t replace( R t oldR� R� ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s N( R$ Re Rf t syst maxintR� Rg RK R R R� R� R� R� ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR 7 s ; t StateMachineErrorc B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR� � s R7 c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR7 � s RW c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRW � s Rr c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRr � s Rq c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRq � s R{ c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR{ � s R~ c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR~ � s RL c B s e Z RS( ( R$ Re ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyRL � s R& c B s e Z d Z RS( s�
Raise from within a transition method to switch to another transition.
Raise with one argument, the new transition name.
( R$ Re Rf ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR& � s R) c B s e Z d Z RS( s�
Raise from within a transition method to switch to another state.
Raise with one or two arguments: new state name, and an optional new
transition name.
( R$ Re Rf ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR) � s i s [ ]c C sG | r | j d | � } n g | j � D] } | j | � j � ^ q( S( s�
Return a list of one-line strings with tabs expanded, no newlines, and
trailing whitespace stripped.
Each tab is expanded with between 1 and `tab_width` spaces, so that the
next character's index becomes a multiple of `tab_width` (8 by default).
Parameters:
- `astring`: a multi-line string.
- `tab_width`: the number of columns between tab stops.
- `convert_whitespace`: convert form feeds and vertical tabs to spaces?
R� ( t subt
splitlinest
expandtabsR� ( t astringt tab_widtht convert_whitespacet
whitespacet s( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt string2lines� s c C sY t j � \ } } } x | j r- | j } q W| j j } | j | | j | j | j f S( s�
Return exception information:
- the exception's class name;
- the exception object;
- the name of the file containing the offending code;
- the line number of the offending code;
- the function name of the offending code.
( R� t exc_infot tb_nextt tb_framet f_codeR$ t co_filenamet tb_linenot co_name( R\ R] t tracebackt code( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyR[ � s
(" Rf t
__docformat__R� Ry R� R� t docutilsR t docutils.utils.error_reportingR R Rh R� R� R� R� R� R� R t ExceptionR� R7 RW Rr Rq R{ R~ RL R& R) Rg Rz R� R[ ( ( ( sF /opt/alt/python27/lib/python2.7/site-packages/docutils/statemachine.pyt <module>i s@ � �� g��
�