a
f=ict\ @ s d dl Z d dlZd dlZd dlmZmZmZmZmZmZm Z m
Z
d dl m Z d dl
mZ d dlZdZe eZeddefdeje j fd efgZed
ZG d d d e jZG d
d de jZG dd dee Zee edddZ dedddZ d/ej eje ee e ee ddd Z!ee
ej e d d d Z"G d d! d!Z#G d"d# d#Z$ej e d$d%d&Z%d'd( Z&e
ej d)d*d+Z'e&d0ej eje e$eeee e eje d, d-d.Z(dS )1 N)List
NamedTupleGenericTypeVarDictCallableSetIterable)Template)StringIOaM
{% if not head %}
{% else %}
{{ head | safe }}
{% endif %}
{{ body | safe }}
{% for diagram in diagrams %}
{{ diagram.title }}
{{ diagram.text }}
{{ diagram.svg }}
{% endfor %}
NamedDiagramnamediagramindexTc s$ e Zd ZdZdZ fddZ ZS )EachItemz
Custom railroad item to compose a:
- Group containing a
- OneOrMore containing a
- Choice of the elements in the Each
with the group label indicating that all must be matched
z[ALL]c s< t jt|d g|R }t j|d}t j|| jd d S )N itemlabel)railroadChoicelen OneOrMoresuper__init__ all_label)selfitemsZ choice_itemZone_or_more_item __class__ k/home/droni/.local/share/virtualenvs/DPS-5Je3_V2c/lib/python3.9/site-packages/pyparsing/diagram/__init__.pyr I s zEachItem.__init__)__name__
__module__ __qualname____doc__r r
__classcell__r" r" r r# r > s r c s& e Zd ZdZed fdd Z ZS )
AnnotatedItemzC
Simple subclass of Group that creates an annotation label
r c s" t j||rd|n|d d S )Nz[{}]r r )r r format)r r r r r" r# r T s zAnnotatedItem.__init__)r$ r% r& r' strr r( r" r" r r# r) O s r) c @ s` e Zd ZdZedef eedddZe edef dddd Z
e d
d Z ed d
dZ
dS )EditablePartialz
Acts like a functools.partial, but can be edited. In other words, it represents a type that hasn't yet been
constructed.
.funcargskwargsc C s || _ || _|| _d S Nr. )r r/ r0 r1 r" r" r# r a s zEditablePartial.__init__EditablePartial[T])r/ returnc O s t |t||dS )z
If you call this function in the same way that you would call the constructor, it will store the arguments
as you expect. For example EditablePartial.from_call(Fraction, 1, 3)() == Fraction(1, 3)
r. )r- list)clsr/ r0 r1 r" r" r# from_callf s zEditablePartial.from_callc C s
| j d S )Nr
)r1 r r" r" r# r
n s zEditablePartial.namer4 c C sL | j }| j }t| j}|j| jv r<|||j7 }| j|i |S )z<
Evaluate the partial and return the result
)r0 copyr1 inspectgetfullargspecr/ varargspop)r r0 r1 Zarg_specr" r" r# __call__r s
zEditablePartial.__call__N)r$ r% r& r' r r r5 dictr classmethodr7 propertyr
r? r" r" r" r# r- X s
r- )diagramsr4 c K sp g }| D ]R}|j du rqt }|j |j |j}|jdkrD|d7 }||d| d qtj f d|i|S )z
Given a list of NamedDiagram, produce a single HTML string that visualises those diagrams
:params kwargs: kwargs to be passed in to the template
Nr z (root) )titletextsvgrC )
r r ZwriteSvgwriter
r appendgetvaluetemplaterender)rC r1 datar iorE r" r" r# railroad_to_html s
rO r3 )partialr4 c C sd t | tr(t| j| _t| j| _| S t | tr@dd | D S t | tr\dd | D S | S dS )zS
Recursively resolves a collection of Partials into whatever type they are
c S s g | ] }t |qS r" resolve_partial).0xr" r" r#
z#resolve_partial..c S s i | ]\}}|t |qS r" rQ )rS keyrT r" r" r#
rV z#resolve_partial..N)
isinstancer- rR r0 r1 r5 r@ r )rP r" r" r# rR s
rR F)elementdiagram_kwargsverticalshow_results_names show_groupsr4 c C s t |pi d}t| |d|||d t| }||v rV| jsBd|| _|| j||dd t|j }t |dkrt
}g } |D ]:}
|
jdkrq~|
jdur~|
j|vr~| |
j | |
q~d d
| D } nd d
|D } t
| d d
dS )a
Convert a pyparsing element tree into a list of diagrams. This is the recommended entrypoint to diagram
creation if you want to access the Railroad tree before it is converted to HTML
:param element: base element of the parser being diagrammed
:param diagram_kwargs: kwargs to pass to the Diagram() constructor
:param vertical: (optional) - int - limit at which number of alternatives should be
shown vertically instead of horizontally
:param show_results_names - bool to indicate whether results name annotations should be
included in the diagram
:param show_groups - bool to indicate whether groups should be highlighted with an unlabeled
surrounding box
r\ N)lookupparentr] r^ r_ rD T)forcer z...c S s g | ] }t |qS r" rQ rS rP r" r" r# rU rV z to_railroad..c S s g | ] }t |qS r" rQ rd r" r" r# rU rV c S s | j S r2 r )Zdiagr" r" r# rV z to_railroad..rW )ConverterState_to_diagram_elementid
customNamer
mark_for_extractionr5 rC valuesr setaddrI sorted) r[ r\ r] r^ r_ ra Zroot_idZdiagsseenZ
deduped_diagsdresolvedr" r" r# to_railroad s6
rt )
specificationexprsr4 c C s | du r dS t t|| kS dS )zF
Returns true if we should return a vertical list of elements
NF)r _visible_exprs)ru rv r" r" r# _should_vertical s rx c @ sH e Zd ZdZd ejeeeee j
e dddZ d edee dd d
Z
dS )
ElementStatez<
State recorded for an individual pyparsing Element
N)r[ convertedrb numberr
parent_indexc C s4 || _ || _|| _|| _|| _|| _d| _d| _d S )NF)r[ r
rz rb r{ r| extractcomplete)r r[ rz rb r{ r
r| r" r" r# r s
zElementState.__init__Frh )el_idstater
rc c C sT d| _ | js2|r|| _n| jjr,| jj| _nd| _|sF| jrPt| jrP|| dS )a
Called when this instance has been seen twice, and thus should eventually be extracted into a sub-diagram
:param el_id: id of the element
:param state: element/diagram state tracker
:param name: name to use for this element's text
:param force: If true, force extraction now, regardless of the state of this. Only useful for extracting the
root element when we know we're finished
TrD N)r} r
r[ rk r~ _worth_extractingextract_into_diagram)r r r r
rc r" r" r# rl s z ElementState.mark_for_extraction)NN)NF)r$ r% r& r' pyparsing
ParserElementr- intr, typingOptionalr boolrl r" r" r" r# ry s ry c @ s e Zd ZdZdeje dddZee dddZ
ee d d
d Z ed d
dZ ed ddZ
edddZedddZedddZdS )rh zR
Stores some state that persists between recursions into the element tree
Nr` c C s. i | _ i | _d| _d| _|p i | _t | _d S )Nr r )_element_diagram_statesrC
unnamed_indexr r\ rn Zextracted_diagram_names)r r\ r" r" r# r . s
zConverterState.__init__)rW valuec C s || j |< d S r2 r )r rW r r" r" r# __setitem__; s zConverterState.__setitem__)rW r4 c C s
| j | S r2 r r rW r" r" r# __getitem__> s zConverterState.__getitem__rg c C s | j |= d S r2 r r r" r" r# __delitem__A s zConverterState.__delitem__c C s
|| j v S r2 r r r" r" r# __contains__D s zConverterState.__contains__r9 c C s | j d7 _ | j S )zT
Generate a number used in the name of an otherwise unnamed diagram
r )r r8 r" r" r# generate_unnamedG s z ConverterState.generate_unnamedc C s | j d7 _ | j S )z;
Generate a number used to index a diagram
r re r8 r" r" r# generate_indexN s z ConverterState.generate_index)r c C s | | }|j rXtjtj|jd}d|j jv r:||j jd< n d|j jv rX||j jd |j< |jj tj
krt|jjd }n|j}tjt |jtjtj |fi | j
|jd| j|< | |= dS )z
Used when we encounter the same token twice in the same tree. When this
happens, we replace all instances of that token with a terminal, and
create a new subdiagram for the token
rF r r )r
r r N)rb r- r7 r NonTerminalr
r1 r| rz r/ Groupr ZDiagramr\ r{ rC )r r positionretcontentr" r" r# r U s* z#ConverterState.extract_into_diagram)N)r$ r% r& r' r r r@ r r ry r r r r r r r r" r" r" r# rh ) s
rh )r[ r4 c C s | }tdd |D S )z
Returns true if this element is worth having its own sub-diagram. Simply, if any of its children
themselves have children, then its complex enough to extract
c s s | ]}| V qd S r2 )recurse)rS childr" r" r# } rV z$_worth_extracting..)r any)r[ childrenr" r" r# r w s r c s6 dt jtjt tttttttjt d fdd
}|S )z
decorator to ensure enhancements to a diagram item (such as results name annotations)
get applied on return from _to_diagram_element (we do this since there are several
returns in _to_diagram_element)
Nr F r[ rb ra r] r name_hintr^ r_ r4 c
sT | |||||||}|rP|d urP| j } | rP| | jr8dnd7 } tjtj|| d}|S )NrD *r* ) resultsName modalResultsr- r7 r r )
r[ rb ra r] r r r^ r_ r element_results_namefnr" r# _inner s$ z0_apply_diagram_item_enhancements.._inner)NNr NFF) r r r r r- rh r r, r )r r r" r r# _apply_diagram_item_enhancements s$
"r rv c s$ t jt jt jjf fdd| D S )Nc s& g | ] }|j s|jst| s|qS r" )rk r rY rS eZnon_diagramming_exprsr" r# rU s z"_visible_exprs..)r ParseElementEnhance
PositionTokenAnd
_ErrorStopr r" r r# rw s
rw r c
C s8 | }|p| jp| jj} t| }
| j} | jsnt| tjfrn|rn|d jsP| } nd} t | j
||||| ||dS t | r|
|v r||
}
|
j |
||d t
jtj|
jd}|S |
|jv rt
jtj|j|
jd d}|S t| tjrV|sdS ttdd |D d kr$t
jtjd
tt|d }n.t||rBt
jtjg d }nt
jtjg d }nBt| tj tj fr|stdS t||rt
jtj dg d }nt
jtj g d }nt| tj r|sdS t
jt!g d }nt| tj"rt
jt#d
d
d}nt| tj$rt
jt#dd
d}nt| tj%r8t
jt#dd
d}n`t| tj&rt|r^t
jt#d
d
d}nt
jtj&d
d
d}n$t| tj'rt
jt#t(| j) d
d}nt| tj*rt
jtj+d
d}nt| tjrt
jtjd
d}nt| tj,rt
jtj,d
d}nt| tj&r t
jtj&d| d}nxt| tj-r<| js||jd< n"d|jv rz||jd |< |d 7 }nd|jv r|jd |= q|rd|jv rt|jd dksd|jv r|jd du rt
tj.| }|
|v rd||
_3|
|v r4||
j4r4||
j3r4|5|
|dur4t
jtj|j|
jd d}|S )ay
Recursively converts a PyParsing Element to a railroad Element
:param lookup: The shared converter state that keeps track of useful things
:param index: The index of this element within the parent
:param parent: The parent of this element in the output tree
:param vertical: Controls at what point we make a list of elements vertical. If this is an integer (the default),
it sets the threshold of the number of items before we go vertical. If True, always go vertical, if False, never
do so
:param name_hint: If provided, this will override the generated name
:param show_results_names: bool flag indicating whether to add annotations for results names
:returns: The converted version of the input element, but as a Partial that hasn't yet been constructed
:param show_groups: bool flag indicating whether to show groups using bounding box
r N)rb ra r] r r r^ r_ )r
r r
c s s | ]}|j |jfV qd S r2 )r
r r r" r" r# r rV z&_to_diagram_element..r rD )r repeat)r NOT)r r Z LOOKAHEADZ
LOOKBEHINDr r* )r[ rz rb r| r{ r )rb ra r] r r^ r_ r T)6r rk r! r$ rj r rY r Locatedri exprr rl r- r7 r r r
rC r1 r r rn r r, rx StackSequenceOr
MatchFirstr ZHorizontalChoiceEachr NotAnyr)
FollowedBy
PrecededByr TokenConvertertypelowerOptr
ZeroOrMoreEmptyZTerminal defaultNamery r insertr~ r} r )r[ rb ra r] r r r^ r_ rv r
r r Zpropagated_nameZ looked_upr Zterminalir r r" r" r# ri s
"
ri )NrZ FF)NNr NFF))r r r r r r r r r r r Zjinja2r
rN r r; Zjinja2_template_sourcerK r, r Z DiagramItemr r r r r r) r- rO rR r r@ r rt rx ry rh r r rw ri r" r" r" r# sp (
* ;
>N ,