transitions-0.8.10+3/ 0000755 0002322 0002322 00000000000 14162545516 014672 5 ustar debalance debalance transitions-0.8.10+3/binder/ 0000755 0002322 0002322 00000000000 14155650047 016133 5 ustar debalance debalance transitions-0.8.10+3/binder/requirements.txt 0000644 0002322 0002322 00000000015 14155650047 021413 0 ustar debalance debalance six
graphviz
transitions-0.8.10+3/binder/postBuild 0000644 0002322 0002322 00000000043 14155650047 020020 0 ustar debalance debalance #!/bin/bash
set -ex
pip install .
transitions-0.8.10+3/binder/apt.txt 0000644 0002322 0002322 00000000011 14155650047 017450 0 ustar debalance debalance graphviz
transitions-0.8.10+3/setup.cfg 0000644 0002322 0002322 00000000226 14155650047 016511 0 ustar debalance debalance [metadata]
description_file = README.md
[check-manifest]
ignore =
.travis.yml
.scrutinizer.yml
appveyor.yml
[bdist_wheel]
universal = 1
transitions-0.8.10+3/README.md 0000644 0002322 0002322 00000241420 14155650047 016152 0 ustar debalance debalance # transitions
[](https://github.com/pytransitions/transitions)
[](https://github.com/pytransitions/transitions/actions?query=workflow%3Apytest)
[](https://coveralls.io/github/pytransitions/transitions?branch=master)
[](https://pypi.org/project/transitions)
[](https://github.com/pytransitions/transitions/compare/0.8.10...master)
[](LICENSE)
[](https://mybinder.org/v2/gh/pytransitions/transitions/master?filepath=examples%2FPlayground.ipynb)
A lightweight, object-oriented state machine implementation in Python with many extensions. Compatible with Python 2.7+ and 3.0+.
## Installation
pip install transitions
... or clone the repo from GitHub and then:
python setup.py install
## Table of Contents
- [Quickstart](#quickstart)
- [Non-Quickstart](#the-non-quickstart)
- [Basic initialization](#basic-initialization)
- [States](#states)
- [Callbacks](#state-callbacks)
- [Checking state](#checking-state)
- [Enumerations](#enum-state)
- [Transitions](#transitions)
- [Automatic transitions](#automatic-transitions-for-all-states)
- [Transitioning from multiple states](#transitioning-from-multiple-states)
- [Reflexive transitions from multiple states](#reflexive-from-multiple-states)
- [Internal transitions](#internal-transitions)
- [Ordered transitions](#ordered-transitions)
- [Queued transitions](#queued-transitions)
- [Conditional transitions](#conditional-transitions)
- [Callbacks](#transition-callbacks)
- [Callable resolution](#resolution)
- [Callback execution order](#execution-order)
- [Passing data](#passing-data)
- [Alternative initialization patterns](#alternative-initialization-patterns)
- [Logging](#logging)
- [(Re-)Storing machine instances](#restoring)
- [Extensions](#extensions)
- [Diagrams](#diagrams)
- [Hierarchical State Machine](#hsm)
- [Threading](#threading)
- [Async](#async)
- [State features](#state-features)
- [Django](#django-support)
- [Bug reports etc.](#bug-reports)
## Quickstart
They say [a good example is worth](https://www.google.com/webhp?ie=UTF-8#q=%22a+good+example+is+worth%22&start=20) 100 pages of API documentation, a million directives, or a thousand words.
Well, "they" probably lie... but here's an example anyway:
```python
from transitions import Machine
import random
class NarcolepticSuperhero(object):
# Define some states. Most of the time, narcoleptic superheroes are just like
# everyone else. Except for...
states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world']
def __init__(self, name):
# No anonymous superheroes on my watch! Every narcoleptic superhero gets
# a name. Any name at all. SleepyMan. SlumberGirl. You get the idea.
self.name = name
# What have we accomplished today?
self.kittens_rescued = 0
# Initialize the state machine
self.machine = Machine(model=self, states=NarcolepticSuperhero.states, initial='asleep')
# Add some transitions. We could also define these using a static list of
# dictionaries, as we did with states above, and then pass the list to
# the Machine initializer as the transitions= argument.
# At some point, every superhero must rise and shine.
self.machine.add_transition(trigger='wake_up', source='asleep', dest='hanging out')
# Superheroes need to keep in shape.
self.machine.add_transition('work_out', 'hanging out', 'hungry')
# Those calories won't replenish themselves!
self.machine.add_transition('eat', 'hungry', 'hanging out')
# Superheroes are always on call. ALWAYS. But they're not always
# dressed in work-appropriate clothing.
self.machine.add_transition('distress_call', '*', 'saving the world',
before='change_into_super_secret_costume')
# When they get off work, they're all sweaty and disgusting. But before
# they do anything else, they have to meticulously log their latest
# escapades. Because the legal department says so.
self.machine.add_transition('complete_mission', 'saving the world', 'sweaty',
after='update_journal')
# Sweat is a disorder that can be remedied with water.
# Unless you've had a particularly long day, in which case... bed time!
self.machine.add_transition('clean_up', 'sweaty', 'asleep', conditions=['is_exhausted'])
self.machine.add_transition('clean_up', 'sweaty', 'hanging out')
# Our NarcolepticSuperhero can fall asleep at pretty much any time.
self.machine.add_transition('nap', '*', 'asleep')
def update_journal(self):
""" Dear Diary, today I saved Mr. Whiskers. Again. """
self.kittens_rescued += 1
@property
def is_exhausted(self):
""" Basically a coin toss. """
return random.random() < 0.5
def change_into_super_secret_costume(self):
print("Beauty, eh?")
```
There, now you've baked a state machine into `NarcolepticSuperhero`. Let's take him/her/it out for a spin...
```python
>>> batman = NarcolepticSuperhero("Batman")
>>> batman.state
'asleep'
>>> batman.wake_up()
>>> batman.state
'hanging out'
>>> batman.nap()
>>> batman.state
'asleep'
>>> batman.clean_up()
MachineError: "Can't trigger event clean_up from state asleep!"
>>> batman.wake_up()
>>> batman.work_out()
>>> batman.state
'hungry'
# Batman still hasn't done anything useful...
>>> batman.kittens_rescued
0
# We now take you live to the scene of a horrific kitten entreement...
>>> batman.distress_call()
'Beauty, eh?'
>>> batman.state
'saving the world'
# Back to the crib.
>>> batman.complete_mission()
>>> batman.state
'sweaty'
>>> batman.clean_up()
>>> batman.state
'asleep' # Too tired to shower!
# Another productive day, Alfred.
>>> batman.kittens_rescued
1
```
While we cannot read the mind of the actual batman, we surely can visualize the current state of our `NarcolepticSuperhero`.
Have a look at the [Diagrams](#diagrams) extensions if you want to know how.
## The non-quickstart
### Basic initialization
Getting a state machine up and running is pretty simple. Let's say you have the object `lump` (an instance of class `Matter`), and you want to manage its states:
```python
class Matter(object):
pass
lump = Matter()
```
You can initialize a (_minimal_) working state machine bound to `lump` like this:
```python
from transitions import Machine
machine = Machine(model=lump, states=['solid', 'liquid', 'gas', 'plasma'], initial='solid')
# Lump now has state!
lump.state
>>> 'solid'
```
I say "minimal", because while this state machine is technically operational, it doesn't actually _do_ anything. It starts in the `'solid'` state, but won't ever move into another state, because no transitions are defined... yet!
Let's try again.
```python
# The states
states=['solid', 'liquid', 'gas', 'plasma']
# And some transitions between states. We're lazy, so we'll leave out
# the inverse phase transitions (freezing, condensation, etc.).
transitions = [
{ 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },
{ 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' },
{ 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' },
{ 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' }
]
# Initialize
machine = Machine(lump, states=states, transitions=transitions, initial='liquid')
# Now lump maintains state...
lump.state
>>> 'liquid'
# And that state can change...
lump.evaporate()
lump.state
>>> 'gas'
lump.trigger('ionize')
lump.state
>>> 'plasma'
```
Notice the shiny new methods attached to the `Matter` instance (`evaporate()`, `ionize()`, etc.). Each method triggers the corresponding transition. You don't have to explicitly define these methods anywhere; the name of each transition is bound to the model passed to the `Machine` initializer (in this case, `lump`).
To be more precise, your model **should not** already contain methods with the same name as event triggers since `transitions` will only attach convenience methods to your model if the spot is not already taken.
If you want to modify that behaviour, have a look at the [FAQ](examples/Frequently%20asked%20questions.ipynb).
Furthermore, there is a method called `trigger` now attached to your model (if it hasn't been there before).
This method lets you execute transitions by name in case dynamic triggering is required.
### States
The soul of any good state machine (and of many bad ones, no doubt) is a set of states. Above, we defined the valid model states by passing a list of strings to the `Machine` initializer. But internally, states are actually represented as `State` objects.
You can initialize and modify States in a number of ways. Specifically, you can:
- pass a string to the `Machine` initializer giving the name(s) of the state(s), or
- directly initialize each new `State` object, or
- pass a dictionary with initialization arguments
The following snippets illustrate several ways to achieve the same goal:
```python
# import Machine and State class
from transitions import Machine, State
# Create a list of 3 states to pass to the Machine
# initializer. We can mix types; in this case, we
# pass one State, one string, and one dict.
states = [
State(name='solid'),
'liquid',
{ 'name': 'gas'}
]
machine = Machine(lump, states)
# This alternative example illustrates more explicit
# addition of states and state callbacks, but the net
# result is identical to the above.
machine = Machine(lump)
solid = State('solid')
liquid = State('liquid')
gas = State('gas')
machine.add_states([solid, liquid, gas])
```
States are initialized *once* when added to the machine and will persist until they are removed from it. In other words: if you alter the attributes of a state object, this change will NOT be reset the next time you enter that state. Have a look at how to [extend state features](#state-features) in case you require some other behaviour.
#### Callbacks
A `State` can also be associated with a list of `enter` and `exit` callbacks, which are called whenever the state machine enters or leaves that state. You can specify callbacks during initialization by passing them to a `State` object constructor, in a state property dictionary, or add them later.
For convenience, whenever a new `State` is added to a `Machine`, the methods `on_enter_«state name»` and `on_exit_«state name»` are dynamically created on the Machine (not on the model!), which allow you to dynamically add new enter and exit callbacks later if you need them.
```python
# Our old Matter class, now with a couple of new methods we
# can trigger when entering or exit states.
class Matter(object):
def say_hello(self): print("hello, new state!")
def say_goodbye(self): print("goodbye, old state!")
lump = Matter()
# Same states as above, but now we give StateA an exit callback
states = [
State(name='solid', on_exit=['say_goodbye']),
'liquid',
{ 'name': 'gas', 'on_exit': ['say_goodbye']}
]
machine = Machine(lump, states=states)
machine.add_transition('sublimate', 'solid', 'gas')
# Callbacks can also be added after initialization using
# the dynamically added on_enter_ and on_exit_ methods.
# Note that the initial call to add the callback is made
# on the Machine and not on the model.
machine.on_enter_gas('say_hello')
# Test out the callbacks...
machine.set_state('solid')
lump.sublimate()
>>> 'goodbye, old state!'
>>> 'hello, new state!'
```
Note that `on_enter_«state name»` callback will *not* fire when a Machine is first initialized. For example if you have an `on_enter_A()` callback defined, and initialize the `Machine` with `initial='A'`, `on_enter_A()` will not be fired until the next time you enter state `A`. (If you need to make sure `on_enter_A()` fires at initialization, you can simply create a dummy initial state and then explicitly call `to_A()` inside the `__init__` method.)
In addition to passing in callbacks when initializing a `State`, or adding them dynamically, it's also possible to define callbacks in the model class itself, which may increase code clarity. For example:
```python
class Matter(object):
def say_hello(self): print("hello, new state!")
def say_goodbye(self): print("goodbye, old state!")
def on_enter_A(self): print("We've just entered state A!")
lump = Matter()
machine = Machine(lump, states=['A', 'B', 'C'])
```
Now, any time `lump` transitions to state `A`, the `on_enter_A()` method defined in the `Matter` class will fire.
#### Checking state
You can always check the current state of the model by either:
- inspecting the `.state` attribute, or
- calling `is_«state name»()`
And if you want to retrieve the actual `State` object for the current state, you can do that through the `Machine` instance's `get_state()` method.
```python
lump.state
>>> 'solid'
lump.is_gas()
>>> False
lump.is_solid()
>>> True
machine.get_state(lump.state).name
>>> 'solid'
```
If you'd like you can choose your own state attribute name by passing the `model_attribute` argument while initializing the `Machine`. This will also change the name of `is_«state name»()` to `is_«model_attribute»_«state name»()` though. Similarly, auto transitions will be named `to_«model_attribute»_«state name»()` instead of `to_«state name»()`. This is done to allow multiple machines to work on the same model with individual state attribute names.
```python
lump = Matter()
machine = Machine(lump, states=['solid', 'liquid', 'gas'], model_attribute='matter_state', initial='solid')
lump.matter_state
>>> 'solid'
# with a custom 'model_attribute', states can also be checked like this:
lump.is_matter_state_solid()
>>> True
lump.to_matter_state_gas()
>>> True
```
#### Enumerations
So far we have seen how we can give state names and use these names to work with our state machine.
If you favour stricter typing and more IDE code completion (or you just can't type 'sesquipedalophobia' any longer because the word scares you) using [Enumerations](https://docs.python.org/3/library/enum.html) might be what you are looking for:
```python
import enum # Python 2.7 users need to have 'enum34' installed
from transitions import Machine
class States(enum.Enum):
ERROR = 0
RED = 1
YELLOW = 2
GREEN = 3
transitions = [['proceed', States.RED, States.YELLOW],
['proceed', States.YELLOW, States.GREEN],
['error', '*', States.ERROR]]
m = Machine(states=States, transitions=transitions, initial=States.RED)
assert m.is_RED()
assert m.state is States.RED
state = m.get_state(States.RED) # get transitions.State object
print(state.name) # >>> RED
m.proceed()
m.proceed()
assert m.is_GREEN()
m.error()
assert m.state is States.ERROR
```
You can mix enums and strings if you like (e.g. `[States.RED, 'ORANGE', States.YELLOW, States.GREEN]`) but note that internally, `transitions` will still handle states by name (`enum.Enum.name`).
Thus, it is not possible to have the states `'GREEN'` and `States.GREEN` at the same time.
### Transitions
Some of the above examples already illustrate the use of transitions in passing, but here we'll explore them in more detail.
As with states, each transition is represented internally as its own object – an instance of class `Transition`. The quickest way to initialize a set of transitions is to pass a dictionary, or list of dictionaries, to the `Machine` initializer. We already saw this above:
```python
transitions = [
{ 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },
{ 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas' },
{ 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas' },
{ 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma' }
]
machine = Machine(model=Matter(), states=states, transitions=transitions)
```
Defining transitions in dictionaries has the benefit of clarity, but can be cumbersome. If you're after brevity, you might choose to define transitions using lists. Just make sure that the elements in each list are in the same order as the positional arguments in the `Transition` initialization (i.e., `trigger`, `source`, `destination`, etc.).
The following list-of-lists is functionally equivalent to the list-of-dictionaries above:
```python
transitions = [
['melt', 'solid', 'liquid'],
['evaporate', 'liquid', 'gas'],
['sublimate', 'solid', 'gas'],
['ionize', 'gas', 'plasma']
]
```
Alternatively, you can add transitions to a `Machine` after initialization:
```python
machine = Machine(model=lump, states=states, initial='solid')
machine.add_transition('melt', source='solid', dest='liquid')
```
The `trigger` argument defines the name of the new triggering method that gets attached to the base model. When this method is called, it will try to execute the transition:
```python
>>> lump.melt()
>>> lump.state
'liquid'
```
By default, calling an invalid trigger will raise an exception:
```python
>>> lump.to_gas()
>>> # This won't work because only objects in a solid state can melt
>>> lump.melt()
transitions.core.MachineError: "Can't trigger event melt from state gas!"
```
This behavior is generally desirable, since it helps alert you to problems in your code. But in some cases, you might want to silently ignore invalid triggers. You can do this by setting `ignore_invalid_triggers=True` (either on a state-by-state basis, or globally for all states):
```python
>>> # Globally suppress invalid trigger exceptions
>>> m = Machine(lump, states, initial='solid', ignore_invalid_triggers=True)
>>> # ...or suppress for only one group of states
>>> states = ['new_state1', 'new_state2']
>>> m.add_states(states, ignore_invalid_triggers=True)
>>> # ...or even just for a single state. Here, exceptions will only be suppressed when the current state is A.
>>> states = [State('A', ignore_invalid_triggers=True), 'B', 'C']
>>> m = Machine(lump, states)
>>> # ...this can be inverted as well if just one state should raise an exception
>>> # since the machine's global value is not applied to a previously initialized state.
>>> states = ['A', 'B', State('C')] # the default value for 'ignore_invalid_triggers' is False
>>> m = Machine(lump, states, ignore_invalid_triggers=True)
```
If you need to know which transitions are valid from a certain state, you can use `get_triggers`:
```
m.get_triggers('solid')
>>> ['melt', 'sublimate']
m.get_triggers('liquid')
>>> ['evaporate']
m.get_triggers('plasma')
>>> []
# you can also query several states at once
m.get_triggers('solid', 'liquid', 'gas', 'plasma')
>>> ['melt', 'evaporate', 'sublimate', 'ionize']
```
#### Automatic transitions for all states
In addition to any transitions added explicitly, a `to_«state»()` method is created automatically whenever a state is added to a `Machine` instance. This method transitions to the target state no matter which state the machine is currently in:
```python
lump.to_liquid()
lump.state
>>> 'liquid'
lump.to_solid()
lump.state
>>> 'solid'
```
If you desire, you can disable this behavior by setting `auto_transitions=False` in the `Machine` initializer.
#### Transitioning from multiple states
A given trigger can be attached to multiple transitions, some of which can potentially begin or end in the same state. For example:
```python
machine.add_transition('transmogrify', ['solid', 'liquid', 'gas'], 'plasma')
machine.add_transition('transmogrify', 'plasma', 'solid')
# This next transition will never execute
machine.add_transition('transmogrify', 'plasma', 'gas')
```
In this case, calling `transmogrify()` will set the model's state to `'solid'` if it's currently `'plasma'`, and set it to `'plasma'` otherwise. (Note that only the _first_ matching transition will execute; thus, the transition defined in the last line above won't do anything.)
You can also make a trigger cause a transition from _all_ states to a particular destination by using the `'*'` wildcard:
```python
machine.add_transition('to_liquid', '*', 'liquid')
```
Note that wildcard transitions will only apply to states that exist at the time of the add_transition() call. Calling a wildcard-based transition when the model is in a state added after the transition was defined will elicit an invalid transition message, and will not transition to the target state.
#### Reflexive transitions from multiple states
A reflexive trigger (trigger that has the same state as source and destination) can easily be added specifying `=` as destination.
This is handy if the same reflexive trigger should be added to multiple states.
For example:
```python
machine.add_transition('touch', ['liquid', 'gas', 'plasma'], '=', after='change_shape')
```
This will add reflexive transitions for all three states with `touch()` as trigger and with `change_shape` executed after each trigger.
#### Internal transitions
In contrast to reflexive transitions, internal transitions will never actually leave the state.
This means that transition-related callbacks such as `before` or `after` will be processed while state-related callbacks `exit` or `enter` will not.
To define a transition to be internal, set the destination to `None`.
```python
machine.add_transition('internal', ['liquid', 'gas'], None, after='change_shape')
```
#### Ordered transitions
A common desire is for state transitions to follow a strict linear sequence. For instance, given states `['A', 'B', 'C']`, you might want valid transitions for `A` → `B`, `B` → `C`, and `C` → `A` (but no other pairs).
To facilitate this behavior, Transitions provides an `add_ordered_transitions()` method in the `Machine` class:
```python
states = ['A', 'B', 'C']
# See the "alternative initialization" section for an explanation of the 1st argument to init
machine = Machine(states=states, initial='A')
machine.add_ordered_transitions()
machine.next_state()
print(machine.state)
>>> 'B'
# We can also define a different order of transitions
machine = Machine(states=states, initial='A')
machine.add_ordered_transitions(['A', 'C', 'B'])
machine.next_state()
print(machine.state)
>>> 'C'
# Conditions can be passed to 'add_ordered_transitions' as well
# If one condition is passed, it will be used for all transitions
machine = Machine(states=states, initial='A')
machine.add_ordered_transitions(conditions='check')
# If a list is passed, it must contain exactly as many elements as the
# machine contains states (A->B, ..., X->A)
machine = Machine(states=states, initial='A')
machine.add_ordered_transitions(conditions=['check_A2B', ..., 'check_X2A'])
# Conditions are always applied starting from the initial state
machine = Machine(states=states, initial='B')
machine.add_ordered_transitions(conditions=['check_B2C', ..., 'check_A2B'])
# With `loop=False`, the transition from the last state to the first state will be omitted (e.g. C->A)
# When you also pass conditions, you need to pass one condition less (len(states)-1)
machine = Machine(states=states, initial='A')
machine.add_ordered_transitions(loop=False)
machine.next_state()
machine.next_state()
machine.next_state() # transitions.core.MachineError: "Can't trigger event next_state from state C!"
```
#### Queued transitions
The default behaviour in Transitions is to process events instantly. This means events within an `on_enter` method will be processed _before_ callbacks bound to `after` are called.
```python
def go_to_C():
global machine
machine.to_C()
def after_advance():
print("I am in state B now!")
def entering_C():
print("I am in state C now!")
states = ['A', 'B', 'C']
machine = Machine(states=states, initial='A')
# we want a message when state transition to B has been completed
machine.add_transition('advance', 'A', 'B', after=after_advance)
# call transition from state B to state C
machine.on_enter_B(go_to_C)
# we also want a message when entering state C
machine.on_enter_C(entering_C)
machine.advance()
>>> 'I am in state C now!'
>>> 'I am in state B now!' # what?
```
The execution order of this example is
```
prepare -> before -> on_enter_B -> on_enter_C -> after.
```
If queued processing is enabled, a transition will be finished before the next transition is triggered:
```python
machine = Machine(states=states, queued=True, initial='A')
...
machine.advance()
>>> 'I am in state B now!'
>>> 'I am in state C now!' # That's better!
```
This results in
```
prepare -> before -> on_enter_B -> queue(to_C) -> after -> on_enter_C.
```
**Important note:** when processing events in a queue, the trigger call will _always_ return `True`, since there is no way to determine at queuing time whether a transition involving queued calls will ultimately complete successfully. This is true even when only a single event is processed.
```python
machine.add_transition('jump', 'A', 'C', conditions='will_fail')
...
# queued=False
machine.jump()
>>> False
# queued=True
machine.jump()
>>> True
```
When a model is removed from the machine, `transitions` will also remove all related events from the queue.
```python
class Model:
def on_enter_B(self):
self.to_C() # add event to queue ...
self.machine.remove_model(self) # aaaand it's gone
```
#### Conditional transitions
Sometimes you only want a particular transition to execute if a specific condition occurs. You can do this by passing a method, or list of methods, in the `conditions` argument:
```python
# Our Matter class, now with a bunch of methods that return booleans.
class Matter(object):
def is_flammable(self): return False
def is_really_hot(self): return True
machine.add_transition('heat', 'solid', 'gas', conditions='is_flammable')
machine.add_transition('heat', 'solid', 'liquid', conditions=['is_really_hot'])
```
In the above example, calling `heat()` when the model is in state `'solid'` will transition to state `'gas'` if `is_flammable` returns `True`. Otherwise, it will transition to state `'liquid'` if `is_really_hot` returns `True`.
For convenience, there's also an `'unless'` argument that behaves exactly like conditions, but inverted:
```python
machine.add_transition('heat', 'solid', 'gas', unless=['is_flammable', 'is_really_hot'])
```
In this case, the model would transition from solid to gas whenever `heat()` fires, provided that both `is_flammable()` and `is_really_hot()` return `False`.
Note that condition-checking methods will passively receive optional arguments and/or data objects passed to triggering methods. For instance, the following call:
```python
lump.heat(temp=74)
# equivalent to lump.trigger('heat', temp=74)
```
... would pass the `temp=74` optional kwarg to the `is_flammable()` check (possibly wrapped in an `EventData` instance). For more on this, see the [Passing data](#passing-data) section below.
#### Callbacks
You can attach callbacks to transitions as well as states. Every transition has `'before'` and `'after'` attributes that contain a list of methods to call before and after the transition executes:
```python
class Matter(object):
def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS")
def disappear(self): print("where'd all the liquid go?")
transitions = [
{ 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'before': 'make_hissing_noises'},
{ 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'after': 'disappear' }
]
lump = Matter()
machine = Machine(lump, states, transitions=transitions, initial='solid')
lump.melt()
>>> "HISSSSSSSSSSSSSSSS"
lump.evaporate()
>>> "where'd all the liquid go?"
```
There is also a `'prepare'` callback that is executed as soon as a transition starts, before any `'conditions'` are checked or other callbacks are executed.
```python
class Matter(object):
heat = False
attempts = 0
def count_attempts(self): self.attempts += 1
def heat_up(self): self.heat = random.random() < 0.25
def stats(self): print('It took you %i attempts to melt the lump!' %self.attempts)
@property
def is_really_hot(self):
return self.heat
states=['solid', 'liquid', 'gas', 'plasma']
transitions = [
{ 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid', 'prepare': ['heat_up', 'count_attempts'], 'conditions': 'is_really_hot', 'after': 'stats'},
]
lump = Matter()
machine = Machine(lump, states, transitions=transitions, initial='solid')
lump.melt()
lump.melt()
lump.melt()
lump.melt()
>>> "It took you 4 attempts to melt the lump!"
```
Note that `prepare` will not be called unless the current state is a valid source for the named transition.
Default actions meant to be executed before or after *every* transition can be passed to `Machine` during initialization with
`before_state_change` and `after_state_change` respectively:
```python
class Matter(object):
def make_hissing_noises(self): print("HISSSSSSSSSSSSSSSS")
def disappear(self): print("where'd all the liquid go?")
states=['solid', 'liquid', 'gas', 'plasma']
lump = Matter()
m = Machine(lump, states, before_state_change='make_hissing_noises', after_state_change='disappear')
lump.to_gas()
>>> "HISSSSSSSSSSSSSSSS"
>>> "where'd all the liquid go?"
```
There are also two keywords for callbacks which should be executed *independently* a) of how many transitions are possible,
b) if any transition succeeds and c) even if an error is raised during the execution of some other callback.
Callbacks passed to `Machine` with `prepare_event` will be executed *once* before processing possible transitions
(and their individual `prepare` callbacks) takes place.
Callbacks of `finalize_event` will be executed regardless of the success of the processed transitions.
Note that if an error occurred it will be attached to `event_data` as `error` and can be retrieved with `send_event=True`.
```python
from transitions import Machine
class Matter(object):
def raise_error(self, event): raise ValueError("Oh no")
def prepare(self, event): print("I am ready!")
def finalize(self, event): print("Result: ", type(event.error), event.error)
states=['solid', 'liquid', 'gas', 'plasma']
lump = Matter()
m = Machine(lump, states, prepare_event='prepare', before_state_change='raise_error',
finalize_event='finalize', send_event=True)
try:
lump.to_gas()
except ValueError:
pass
print(lump.state)
# >>> I am ready!
# >>> Result: Oh no
# >>> initial
```
Sometimes things just don't work out as intended and we need to handle exceptions and clean up the mess to keep things going.
We can pass callbacks to `on_exception` to do this:
```python
from transitions import Machine
class Matter(object):
def raise_error(self, event): raise ValueError("Oh no")
def handle_error(self, event):
print("Fixing things ...")
del event.error # it did not happen if we cannot see it ...
states=['solid', 'liquid', 'gas', 'plasma']
lump = Matter()
m = Machine(lump, states, before_state_change='raise_error', on_exception='handle_error', send_event=True)
try:
lump.to_gas()
except ValueError:
pass
print(lump.state)
# >>> Fixing things ...
# >>> initial
```
### Callable resolution
As you have probably already realized, the standard way of passing callables to states, conditions and transitions is by name. When processing callbacks and conditions, `transitions` will use their name to retrieve the related callable from the model. If the method cannot be retrieved and it contains dots, `transitions` will treat the name as a path to a module function and try to import it. Alternatively, you can pass names of properties or attributes. They will be wrapped into functions but cannot receive event data for obvious reasons. You can also pass callables such as (bound) functions directly. As mentioned earlier, you can also pass lists/tuples of callables names to the callback parameters. Callbacks will be executed in the order they were added.
```python
from transitions import Machine
from mod import imported_func
import random
class Model(object):
def a_callback(self):
imported_func()
@property
def a_property(self):
""" Basically a coin toss. """
return random.random() < 0.5
an_attribute = False
model = Model()
machine = Machine(model=model, states=['A'], initial='A')
machine.add_transition('by_name', 'A', 'A', conditions='a_property', after='a_callback')
machine.add_transition('by_reference', 'A', 'A', unless=['a_property', 'an_attribute'], after=model.a_callback)
machine.add_transition('imported', 'A', 'A', after='mod.imported_func')
model.by_name()
model.by_reference()
model.imported()
```
The callable resolution is done in `Machine.resolve_callable`.
This method can be overridden in case more complex callable resolution strategies are required.
**Example**
```python
class CustomMachine(Machine):
@staticmethod
def resolve_callable(func, event_data):
# manipulate arguments here and return func, or super() if no manipulation is done.
super(CustomMachine, CustomMachine).resolve_callable(func, event_data)
```
### Callback execution order
In summary, there are currently three ways to trigger events. You can call a model's convenience functions like `lump.melt()`,
execute triggers by name such as `lump.trigger("melt")` or dispatch events on multiple models with `machine.dispatch("melt")`
(see section about multiple models in [alternative initialization patterns](#alternative-initialization-patterns)).
Callbacks on transitions are then executed in the following order:
| Callback | Current State | Comments |
|--------------------------------|:-------------:|-------------------------------------------------------------|
| `'machine.prepare_event'` | `source` | executed *once* before individual transitions are processed |
| `'transition.prepare'` | `source` | executed as soon as the transition starts |
| `'transition.conditions'` | `source` | conditions *may* fail and halt the transition |
| `'transition.unless'` | `source` | conditions *may* fail and halt the transition |
| `'machine.before_state_change'`| `source` | default callbacks declared on model |
| `'transition.before'` | `source` | |
| `'state.on_exit'` | `source` | callbacks declared on the source state |
| `` | | |
| `'state.on_enter'` | `destination` | callbacks declared on the destination state |
| `'transition.after'` | `destination` | |
| `'machine.after_state_change'` | `destination` | default callbacks declared on model |
| `'machine.on_exception'` | `source/destination` | callbacks will be executed when an exception has been raised |
| `'machine.finalize_event'` | `source/destination` | callbacks will be executed even if no transition took place or an exception has been raised |
If any callback raises an exception, the processing of callbacks is not continued. This means that when an error occurs before the transition (in `state.on_exit` or earlier), it is halted. In case there is a raise after the transition has been conducted (in `state.on_enter` or later), the state change persists and no rollback is happening. Callbacks specified in `machine.finalize_event` will always be executed unless the exception is raised by a finalizing callback itself. Note that each callback sequence has to be finished before the next stage is executed. Blocking callbacks will halt the execution order and therefore block the `trigger` or `dispatch` call itself. If you want callbacks to be executed in parallel, you could have a look at the [extensions](#extensions) `AsyncMachine` for asynchronous processing or `LockedMachine` for threading.
### Passing data
Sometimes you need to pass the callback functions registered at machine initialization some data that reflects the model's current state.
Transitions allows you to do this in two different ways.
First (the default), you can pass any positional or keyword arguments directly to the trigger methods (created when you call `add_transition()`):
```python
class Matter(object):
def __init__(self): self.set_environment()
def set_environment(self, temp=0, pressure=101.325):
self.temp = temp
self.pressure = pressure
def print_temperature(self): print("Current temperature is %d degrees celsius." % self.temp)
def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure)
lump = Matter()
machine = Machine(lump, ['solid', 'liquid'], initial='solid')
machine.add_transition('melt', 'solid', 'liquid', before='set_environment')
lump.melt(45) # positional arg;
# equivalent to lump.trigger('melt', 45)
lump.print_temperature()
>>> 'Current temperature is 45 degrees celsius.'
machine.set_state('solid') # reset state so we can melt again
lump.melt(pressure=300.23) # keyword args also work
lump.print_pressure()
>>> 'Current pressure is 300.23 kPa.'
```
You can pass any number of arguments you like to the trigger.
There is one important limitation to this approach: every callback function triggered by the state transition must be able to handle _all_ of the arguments. This may cause problems if the callbacks each expect somewhat different data.
To get around this, Transitions supports an alternate method for sending data. If you set `send_event=True` at `Machine` initialization, all arguments to the triggers will be wrapped in an `EventData` instance and passed on to every callback. (The `EventData` object also maintains internal references to the source state, model, transition, machine, and trigger associated with the event, in case you need to access these for anything.)
```python
class Matter(object):
def __init__(self):
self.temp = 0
self.pressure = 101.325
# Note that the sole argument is now the EventData instance.
# This object stores positional arguments passed to the trigger method in the
# .args property, and stores keywords arguments in the .kwargs dictionary.
def set_environment(self, event):
self.temp = event.kwargs.get('temp', 0)
self.pressure = event.kwargs.get('pressure', 101.325)
def print_pressure(self): print("Current pressure is %.2f kPa." % self.pressure)
lump = Matter()
machine = Machine(lump, ['solid', 'liquid'], send_event=True, initial='solid')
machine.add_transition('melt', 'solid', 'liquid', before='set_environment')
lump.melt(temp=45, pressure=1853.68) # keyword args
lump.print_pressure()
>>> 'Current pressure is 1853.68 kPa.'
```
### Alternative initialization patterns
In all of the examples so far, we've attached a new `Machine` instance to a separate model (`lump`, an instance of class `Matter`). While this separation keeps things tidy (because you don't have to monkey patch a whole bunch of new methods into the `Matter` class), it can also get annoying, since it requires you to keep track of which methods are called on the state machine, and which ones are called on the model that the state machine is bound to (e.g., `lump.on_enter_StateA()` vs. `machine.add_transition()`).
Fortunately, Transitions is flexible, and supports two other initialization patterns.
First, you can create a standalone state machine that doesn't require another model at all. Simply omit the model argument during initialization:
```python
machine = Machine(states=states, transitions=transitions, initial='solid')
machine.melt()
machine.state
>>> 'liquid'
```
If you initialize the machine this way, you can then attach all triggering events (like `evaporate()`, `sublimate()`, etc.) and all callback functions directly to the `Machine` instance.
This approach has the benefit of consolidating all of the state machine functionality in one place, but can feel a little bit unnatural if you think state logic should be contained within the model itself rather than in a separate controller.
An alternative (potentially better) approach is to have the model inherit from the `Machine` class. Transitions is designed to support inheritance seamlessly. (just be sure to override class `Machine`'s `__init__` method!):
```python
class Matter(Machine):
def say_hello(self): print("hello, new state!")
def say_goodbye(self): print("goodbye, old state!")
def __init__(self):
states = ['solid', 'liquid', 'gas']
Machine.__init__(self, states=states, initial='solid')
self.add_transition('melt', 'solid', 'liquid')
lump = Matter()
lump.state
>>> 'solid'
lump.melt()
lump.state
>>> 'liquid'
```
Here you get to consolidate all state machine functionality into your existing model, which often feels more natural than sticking all of the functionality we want in a separate standalone `Machine` instance.
A machine can handle multiple models which can be passed as a list like `Machine(model=[model1, model2, ...])`.
In cases where you want to add models *as well as* the machine instance itself, you can pass the class variable placeholder (string) `Machine.self_literal` during initialization like `Machine(model=[Machine.self_literal, model1, ...])`.
You can also create a standalone machine, and register models dynamically via `machine.add_model` by passing `model=None` to the constructor.
Furthermore, you can use `machine.dispatch` to trigger events on all currently added models.
Remember to call `machine.remove_model` if machine is long-lasting and your models are temporary and should be garbage collected:
```python
class Matter():
pass
lump1 = Matter()
lump2 = Matter()
# setting 'model' to None or passing an empty list will initialize the machine without a model
machine = Machine(model=None, states=states, transitions=transitions, initial='solid')
machine.add_model(lump1)
machine.add_model(lump2, initial='liquid')
lump1.state
>>> 'solid'
lump2.state
>>> 'liquid'
# custom events as well as auto transitions can be dispatched to all models
machine.dispatch("to_plasma")
lump1.state
>>> 'plasma'
assert lump1.state == lump2.state
machine.remove_model([lump1, lump2])
del lump1 # lump1 is garbage collected
del lump2 # lump2 is garbage collected
```
If you don't provide an initial state in the state machine constructor, `transitions` will create and add a default state called `'initial'`.
If you do not want a default initial state, you can pass `initial=None`.
However, in this case you need to pass an initial state every time you add a model.
```python
machine = Machine(model=None, states=states, transitions=transitions, initial=None)
machine.add_model(Matter())
>>> "MachineError: No initial state configured for machine, must specify when adding model."
machine.add_model(Matter(), initial='liquid')
```
Models with multiple states could attach multiple machines using different `model_attribute` values. As mentioned in [Checking state](#checking-state), this will add custom `is/to__` functions:
```python
lump = Matter()
matter_machine = Machine(lump, states=['solid', 'liquid', 'gas'], initial='solid')
# add a second machine to the same model but assign a different state attribute
shipment_machine = Machine(lump, states=['delivered', 'shipping'], initial='delivered', model_attribute='shipping_state')
lump.state
>>> 'solid'
lump.is_solid() # check the default field
>>> True
lump.shipping_state
>>> 'delivered'
lump.is_shipping_state_delivered() # check the custom field.
>>> True
lump.to_shipping_state_shipping()
>>> True
lump.is_shipping_state_delivered()
>>> False
```
### Logging
Transitions includes very rudimentary logging capabilities. A number of events – namely, state changes, transition triggers, and conditional checks – are logged as INFO-level events using the standard Python `logging` module. This means you can easily configure logging to standard output in a script:
```python
# Set up logging; The basic log level will be DEBUG
import logging
logging.basicConfig(level=logging.DEBUG)
# Set transitions' log level to INFO; DEBUG messages will be omitted
logging.getLogger('transitions').setLevel(logging.INFO)
# Business as usual
machine = Machine(states=states, transitions=transitions, initial='solid')
...
```
### (Re-)Storing machine instances
Machines are picklable and can be stored and loaded with `pickle`. For Python 3.3 and earlier `dill` is required.
```python
import dill as pickle # only required for Python 3.3 and earlier
m = Machine(states=['A', 'B', 'C'], initial='A')
m.to_B()
m.state
>>> B
# store the machine
dump = pickle.dumps(m)
# load the Machine instance again
m2 = pickle.loads(dump)
m2.state
>>> B
m2.states.keys()
>>> ['A', 'B', 'C']
```
### Extensions
Even though the core of transitions is kept lightweight, there are a variety of MixIns to extend its functionality. Currently supported are:
- **Diagrams** to visualize the current state of a machine
- **Hierarchical State Machines** for nesting and reuse
- **Threadsafe Locks** for parallel execution
- **Async callbacks** for asynchronous execution
- **Custom States** for extended state-related behaviour
There are two mechanisms to retrieve a state machine instance with the desired features enabled.
The first approach makes use of the convenience `factory` with the four parameters `graph`, `nested`, `locked` or `asyncio` set to `True` if the feature is required:
```python
from transitions.extensions import MachineFactory
# create a machine with mixins
diagram_cls = MachineFactory.get_predefined(graph=True)
nested_locked_cls = MachineFactory.get_predefined(nested=True, locked=True)
async_machine_cls = MachineFactory.get_predefined(asyncio=True)
# create instances from these classes
# instances can be used like simple machines
machine1 = diagram_cls(model, state, transitions)
machine2 = nested_locked_cls(model, state, transitions)
```
This approach targets experimental use since in this case the underlying classes do not have to be known.
However, classes can also be directly imported from `transitions.extensions`. The naming scheme is as follows:
| | Diagrams | Nested | Locked | Asyncio |
| -----------------------------: | :------: | :----: | :----: | :---: |
| Machine | ✘ | ✘ | ✘ | ✘ |
| GraphMachine | ✓ | ✘ | ✘ | ✘ |
| HierarchicalMachine | ✘ | ✓ | ✘ | ✘ |
| LockedMachine | ✘ | ✘ | ✓ | ✘ |
| HierarchicalGraphMachine | ✓ | ✓ | ✘ | ✘ |
| LockedGraphMachine | ✓ | ✘ | ✓ | ✘ |
| LockedHierarchicalMachine | ✘ | ✓ | ✓ | ✘ |
| LockedHierarchicalGraphMachine | ✓ | ✓ | ✓ | ✘ |
| AsyncMachine | ✘ | ✘ | ✘ | ✓ |
| AsyncGraphMachine | ✓ | ✘ | ✘ | ✓ |
| HierarchicalAsyncMachine | ✘ | ✓ | ✘ | ✓ |
| HierarchicalAsyncGraphMachine | ✓ | ✓ | ✘ | ✓ |
To use a feature-rich state machine, one could write:
```python
from transitions.extensions import LockedHierarchicalGraphMachine as LHGMachine
machine = LHGMachine(model, states, transitions)
```
#### Diagrams
Additional Keywords:
* `title` (optional): Sets the title of the generated image.
* `show_conditions` (default False): Shows conditions at transition edges
* `show_auto_transitions` (default False): Shows auto transitions in graph
* `show_state_attributes` (default False): Show callbacks (enter, exit), tags and timeouts in graph
Transitions can generate basic state diagrams displaying all valid transitions between states. To use the graphing functionality, you'll need to have `graphviz` and/or `pygraphviz` installed:
To generate graphs with the package `graphviz`, you need to install [Graphviz](https://graphviz.org/) manually or via a package manager.
sudo apt-get install graphviz graphviz-dev # Ubuntu and Debian
brew install graphviz # MacOS
conda install graphviz python-graphviz # (Ana)conda
Now you can install the actual Python packages
pip install graphviz pygraphviz # install graphviz and/or pygraphviz manually...
pip install transitions[diagrams] # ... or install transitions with 'diagrams' extras which currently depends on pygraphviz
Currently, `GraphMachine` will use `pygraphviz` when available and fall back to `graphviz` when `pygraphviz` cannot be
found. This can be overridden by passing `use_pygraphviz=False` to the constructor. Note that this default might change
in the future and `pygraphviz` support may be dropped.
With `Model.get_graph()` you can get the current graph or the region of interest (roi) and draw it like this:
```python
# import transitions
from transitions.extensions import GraphMachine
m = Model()
# without further arguments pygraphviz will be used
machine = GraphMachine(model=m, ...)
# when you want to use graphviz explicitly
machine = GraphMachine(model=m, use_pygraphviz=False, ...)
# in cases where auto transitions should be visible
machine = GraphMachine(model=m, show_auto_transitions=True, ...)
# draw the whole graph ...
m.get_graph().draw('my_state_diagram.png', prog='dot')
# ... or just the region of interest
# (previous state, active state and all reachable states)
roi = m.get_graph(show_roi=True).draw('my_state_diagram.png', prog='dot')
```
This produces something like this:
Independent of the backend you use, the draw function also accepts a file descriptor or a binary stream as the first argument. If you set this parameter to `None`, the byte stream will be returned:
```python
import io
with open('a_graph.png', 'bw') as f:
# you need to pass the format when you pass objects instead of filenames.
m.get_graph().draw(f, format="png", prog='dot')
# you can pass a (binary) stream too
b = io.BytesIO()
m.get_graph().draw(b, format="png", prog='dot')
# or just handle the binary string yourself
result = m.get_graph().draw(None, format="png", prog='dot')
assert result == b.getvalue()
```
References and partials passed as callbacks will be resolved as good as possible:
```python
from transitions.extensions import GraphMachine
from functools import partial
class Model:
def clear_state(self, deep=False, force=False):
print("Clearing state ...")
return True
model = Model()
machine = GraphMachine(model=model, states=['A', 'B', 'C'],
transitions=[
{'trigger': 'clear', 'source': 'B', 'dest': 'A', 'conditions': model.clear_state},
{'trigger': 'clear', 'source': 'C', 'dest': 'A',
'conditions': partial(model.clear_state, False, force=True)},
],
initial='A', show_conditions=True)
model.get_graph().draw('my_state_diagram.png', prog='dot')
```
This should produce something similar to this:
If the format of references does not suit your needs, you can override the static method `GraphMachine.format_references`. If you want to skip reference entirely, just let `GraphMachine.format_references` return `None`.
Also, have a look at our [example](./examples) IPython/Jupyter notebooks for a more detailed example about how to use and edit graphs.
### Hierarchical State Machine (HSM)
Transitions includes an extension module which allows nesting states.
This allows us to create contexts and to model cases where states are related to certain subtasks in the state machine.
To create a nested state, either import `NestedState` from transitions or use a dictionary with the initialization arguments `name` and `children`.
Optionally, `initial` can be used to define a sub state to transit to, when the nested state is entered.
```python
from transitions.extensions import HierarchicalMachine
states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}]
transitions = [
['walk', 'standing', 'walking'],
['stop', 'walking', 'standing'],
['drink', '*', 'caffeinated'],
['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'],
['relax', 'caffeinated', 'standing']
]
machine = HierarchicalMachine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True)
machine.walk() # Walking now
machine.stop() # let's stop for a moment
machine.drink() # coffee time
machine.state
>>> 'caffeinated'
machine.walk() # we have to go faster
machine.state
>>> 'caffeinated_running'
machine.stop() # can't stop moving!
machine.state
>>> 'caffeinated_running'
machine.relax() # leave nested state
machine.state # phew, what a ride
>>> 'standing'
# machine.on_enter_caffeinated_running('callback_method')
```
A configuration making use of `initial` could look like this:
```python
# ...
states = ['standing', 'walking', {'name': 'caffeinated', 'initial': 'dithering', 'children': ['dithering', 'running']}]
transitions = [
['walk', 'standing', 'walking'],
['stop', 'walking', 'standing'],
# this transition will end in 'caffeinated_dithering'...
['drink', '*', 'caffeinated'],
# ... that is why we do not need do specify 'caffeinated' here anymore
['walk', 'caffeinated_dithering', 'caffeinated_running'],
['relax', 'caffeinated', 'standing']
]
# ...
```
The `initial` keyword of the `HierarchicalMachine` constructor accepts nested states (e.g. `initial='caffeinated_running'`) and a list of states which is considered to be a parallel state (e.g. `initial=['A', 'B']`) or the current state of another model (`initial=model.state`) which should be effectively one of the previous mentioned options. Note that when passing a string, `transition` will check the targeted state for `initial` substates and use this as an entry state. This will be done recursively until a substate does not mention an initial state. Parallel states or a state passed as a list will be used 'as is' and no further initial evaluation will be conducted.
Note that your previously created state object *must be* a `NestedState` or a derived class of it.
The standard `State` class used in simple `Machine` instances lacks features required for nesting.
```python
from transitions.extensions.nesting import HierarchicalMachine, NestedState
from transitions import State
m = HierarchicalMachine(states=['A'], initial='initial')
m.add_state('B') # fine
m.add_state({'name': 'C'}) # also fine
m.add_state(NestedState('D')) # fine as well
m.add_state(State('E')) # does not work!
```
Some things that have to be considered when working with nested states: State *names are concatenated* with `NestedState.separator`.
Currently the separator is set to underscore ('_') and therefore behaves similar to the basic machine.
This means a substate `bar` from state `foo` will be known by `foo_bar`. A substate `baz` of `bar` will be referred to as `foo_bar_baz` and so on.
When entering a substate, `enter` will be called for all parent states. The same is true for exiting substates.
Third, nested states can overwrite transition behaviour of their parents.
If a transition is not known to the current state it will be delegated to its parent.
**This means that in the standard configuration, state names in HSMs MUST NOT contain underscores.**
For `transitions` it's impossible to tell whether `machine.add_state('state_name')` should add a state named `state_name` or add a substate `name` to the state `state`.
In some cases this is not sufficient however.
For instance if state names consist of more than one word and you want/need to use underscore to separate them instead of `CamelCase`.
To deal with this, you can change the character used for separation quite easily.
You can even use fancy unicode characters if you use Python 3.
Setting the separator to something else than underscore changes some of the behaviour (auto_transition and setting callbacks) though:
```python
from transitions.extensions import HierarchicalMachine
from transitions.extensions.nesting import NestedState
NestedState.separator = '↦'
states = ['A', 'B',
{'name': 'C', 'children':['1', '2',
{'name': '3', 'children': ['a', 'b', 'c']}
]}
]
transitions = [
['reset', 'C', 'A'],
['reset', 'C↦2', 'C'] # overwriting parent reset
]
# we rely on auto transitions
machine = HierarchicalMachine(states=states, transitions=transitions, initial='A')
machine.to_B() # exit state A, enter state B
machine.to_C() # exit B, enter C
machine.to_C.s3.a() # enter C↦a; enter C↦3↦a;
machine.state
>>> 'C↦3↦a'
assert machine.is_C.s3.a()
machine.to('C↦2') # not interactive; exit C↦3↦a, exit C↦3, enter C↦2
machine.reset() # exit C↦2; reset C has been overwritten by C↦3
machine.state
>>> 'C'
machine.reset() # exit C, enter A
machine.state
>>> 'A'
# s.on_enter('C↦3↦a', 'callback_method')
```
Instead of `to_C_3_a()` auto transition is called as `to_C.s3.a()`. If your substate starts with a digit, transitions adds a prefix 's' ('3' becomes 's3') to the auto transition `FunctionWrapper` to comply with the attribute naming scheme of Python.
If interactive completion is not required, `to('C↦3↦a')` can be called directly. Additionally, `on_enter/exit_<>` is replaced with `on_enter/exit(state_name, callback)`. State checks can be conducted in a similar fashion. Instead of `is_C_3_a()`, the `FunctionWrapper` variant `is_C.s3.a()` can be used.
To check whether the current state is a substate of a specific state, `is_state` supports the keyword `allow_substates`:
```python
machine.state
>>> 'C.2.a'
machine.is_C() # checks for specific states
>>> False
machine.is_C(allow_substates=True)
>>> True
assert machine.is_C.s2() is False
assert machine.is_C.s2(allow_substates=True) # FunctionWrapper support allow_substate as well
```
*new in 0.8.0*
You can use enumerations in HSMs as well but keep in mind that `Enum` are compared by value.
If you have a value more than once in a state tree those states cannot be distinguished.
```python
states = [States.RED, States.YELLOW, {'name': States.GREEN, 'children': ['tick', 'tock']}]
states = ['A', {'name': 'B', 'children': states, 'initial': States.GREEN}, States.GREEN]
machine = HierarchicalMachine(states=states)
machine.to_B()
machine.is_GREEN() # returns True even though the actual state is B_GREEN
```
*new in 0.8.0*
`HierarchicalMachine` has been rewritten from scratch to support parallel states and better isolation of nested states.
This involves some tweaks based on community feedback.
To get an idea of processing order and configuration have a look at the following example:
```python
from transitions.extensions.nesting import HierarchicalMachine
import logging
states = ['A', 'B', {'name': 'C', 'parallel': [{'name': '1', 'children': ['a', 'b', 'c'], 'initial': 'a',
'transitions': [['go', 'a', 'b']]},
{'name': '2', 'children': ['x', 'y', 'z'], 'initial': 'z'}],
'transitions': [['go', '2_z', '2_x']]}]
transitions = [['reset', 'C_1_b', 'B']]
logging.basicConfig(level=logging.INFO)
machine = HierarchicalMachine(states=states, transitions=transitions, initial='A')
machine.to_C()
# INFO:transitions.extensions.nesting:Exited state A
# INFO:transitions.extensions.nesting:Entered state C
# INFO:transitions.extensions.nesting:Entered state C_1
# INFO:transitions.extensions.nesting:Entered state C_2
# INFO:transitions.extensions.nesting:Entered state C_1_a
# INFO:transitions.extensions.nesting:Entered state C_2_z
machine.go()
# INFO:transitions.extensions.nesting:Exited state C_1_a
# INFO:transitions.extensions.nesting:Entered state C_1_b
# INFO:transitions.extensions.nesting:Exited state C_2_z
# INFO:transitions.extensions.nesting:Entered state C_2_x
machine.reset()
# INFO:transitions.extensions.nesting:Exited state C_1_b
# INFO:transitions.extensions.nesting:Exited state C_2_x
# INFO:transitions.extensions.nesting:Exited state C_1
# INFO:transitions.extensions.nesting:Exited state C_2
# INFO:transitions.extensions.nesting:Exited state C
# INFO:transitions.extensions.nesting:Entered state B
```
When using `parallel` instead of `children`, `transitions` will enter all states of the passed list at the same time.
Which substate to enter is defined by `initial` which should *always* point to a direct substate.
A novel feature is to define local transitions by passing the `transitions` keyword in a state definition.
The above defined transition `['go', 'a', 'b']` is only valid in `C_1`.
While you can reference substates as done in `['go', '2_z', '2_x']` you cannot reference parent states directly in locally defined transitions.
When a parent state is exited, its children will also be exited.
In addition to the processing order of transitions known from `Machine` where transitions are considered in the order they were added, `HierarchicalMachine` considers hierarchy as well.
Transitions defined in substates will be evaluated first (e.g. `C_1_a` is left before `C_2_z`) and transitions defined with wildcard `*` will (for now) only add transitions to root states (in this example `A`, `B`, `C`)
Starting with *0.8.0* nested states can be added directly and will issue the creation of parent states on-the-fly:
```python
m = HierarchicalMachine(states=['A'], initial='A')
m.add_state('B_1_a')
m.to_B_1()
assert m.is_B(allow_substates=True)
```
#### Reuse of previously created HSMs
Besides semantic order, nested states are very handy if you want to specify state machines for specific tasks and plan to reuse them.
Before *0.8.0*, a `HierarchicalMachine` would not integrate the machine instance itself but the states and transitions by creating copies of them.
However, since *0.8.0* `(Nested)State` instances are just **referenced** which means changes in one machine's collection of states and events will influence the other machine instance. Models and their state will not be shared though.
Note that events and transitions are also copied by reference and will be shared by both instances if you do not use the `remap` keyword.
This change was done to be more in line with `Machine` which also uses passed `State` instances by reference.
```python
count_states = ['1', '2', '3', 'done']
count_trans = [
['increase', '1', '2'],
['increase', '2', '3'],
['decrease', '3', '2'],
['decrease', '2', '1'],
['done', '3', 'done'],
['reset', '*', '1']
]
counter = HierarchicalMachine(states=count_states, transitions=count_trans, initial='1')
counter.increase() # love my counter
states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}]
transitions = [
['collect', '*', 'collecting'],
['wait', '*', 'waiting'],
['count', 'collecting', 'counting']
]
collector = HierarchicalMachine(states=states, transitions=transitions, initial='waiting')
collector.collect() # collecting
collector.count() # let's see what we got; counting_1
collector.increase() # counting_2
collector.increase() # counting_3
collector.done() # collector.state == counting_done
collector.wait() # collector.state == waiting
```
If a `HierarchicalMachine` is passed with the `children` keyword, the initial state of this machine will be assigned to the new parent state.
In the above example we see that entering `counting` will also enter `counting_1`.
If this is undesired behaviour and the machine should rather halt in the parent state, the user can pass `initial` as `False` like `{'name': 'counting', 'children': counter, 'initial': False}`.
Sometimes you want such an embedded state collection to 'return' which means after it is done it should exit and transit to one of your super states.
To achieve this behaviour you can remap state transitions.
In the example above we would like the counter to return if the state `done` was reached.
This is done as follows:
```python
states = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}]
... # same as above
collector.increase() # counting_3
collector.done()
collector.state
>>> 'waiting' # be aware that 'counting_done' will be removed from the state machine
```
As mentioned above, using `remap` will **copy** events and transitions since they could not be valid in the original state machine.
If a reused state machine does not have a final state, you can of course add the transitions manually.
If 'counter' had no 'done' state, we could just add `['done', 'counter_3', 'waiting']` to achieve the same behaviour.
In cases where you want states and transitions to be copied by value rather than reference (for instance, if you want to keep the pre-0.8 behaviour) you can do so by creating a `NestedState` and assigning deep copies of the machine's events and states to it.
```python
from transitions.extensions.nesting import NestedState
from copy import deepcopy
# ... configuring and creating counter
counting_state = NestedState(name="counting", initial='1')
counting_state.states = deepcopy(counter.states)
counting_state.events = deepcopy(counter.events)
states = ['waiting', 'collecting', counting_state]
```
For complex state machines, sharing configurations rather than instantiated machines might be more feasible.
Especially since instantiated machines must be derived from `HierarchicalMachine`.
Such configurations can be stored and loaded easily via JSON or YAML (see the [FAQ](examples/Frequently%20asked%20questions.ipynb)).
`HierarchicalMachine` allows defining substates either with the keyword `children` or `states`.
If both are present, only `children` will be considered.
```python
counter_conf = {
'name': 'counting',
'states': ['1', '2', '3', 'done'],
'transitions': [
['increase', '1', '2'],
['increase', '2', '3'],
['decrease', '3', '2'],
['decrease', '2', '1'],
['done', '3', 'done'],
['reset', '*', '1']
],
'initial': '1'
}
collector_conf = {
'name': 'collector',
'states': ['waiting', 'collecting', counter_conf],
'transitions': [
['collect', '*', 'collecting'],
['wait', '*', 'waiting'],
['count', 'collecting', 'counting']
],
'initial': 'waiting'
}
collector = HierarchicalMachine(**collector_conf)
collector.collect()
collector.count()
collector.increase()
assert collector.is_counting_2()
```
#### Threadsafe(-ish) State Machine
In cases where event dispatching is done in threads, one can use either `LockedMachine` or `LockedHierarchicalMachine` where **function access** (!sic) is secured with reentrant locks.
This does not save you from corrupting your machine by tinkering with member variables of your model or state machine.
```python
from transitions.extensions import LockedMachine
from threading import Thread
import time
states = ['A', 'B', 'C']
machine = LockedMachine(states=states, initial='A')
# let us assume that entering B will take some time
thread = Thread(target=machine.to_B)
thread.start()
time.sleep(0.01) # thread requires some time to start
machine.to_C() # synchronized access; won't execute before thread is done
# accessing attributes directly
thread = Thread(target=machine.to_B)
thread.start()
machine.new_attrib = 42 # not synchronized! will mess with execution order
```
Any python context manager can be passed in via the `machine_context` keyword argument:
```python
from transitions.extensions import LockedMachine
from threading import RLock
states = ['A', 'B', 'C']
lock1 = RLock()
lock2 = RLock()
machine = LockedMachine(states=states, initial='A', machine_context=[lock1, lock2])
```
Any contexts via `machine_model` will be shared between all models registered with the `Machine`.
Per-model contexts can be added as well:
```python
lock3 = RLock()
machine.add_model(model, model_context=lock3)
```
It's important that all user-provided context managers are re-entrant since the state machine will call them multiple
times, even in the context of a single trigger invocation.
#### Using async callbacks
If you are using Python 3.7 or later, you can use `AsyncMachine` to work with asynchronous callbacks.
You can mix synchronous and asynchronous callbacks if you like but this may have undesired side effects.
Note that events need to be awaited and the event loop must also be handled by you.
```python
from transitions.extensions.asyncio import AsyncMachine
import asyncio
import time
class AsyncModel:
def prepare_model(self):
print("I am synchronous.")
self.start_time = time.time()
async def before_change(self):
print("I am asynchronous and will block now for 100 milliseconds.")
await asyncio.sleep(0.1)
print("I am done waiting.")
def sync_before_change(self):
print("I am synchronous and will block the event loop (what I probably shouldn't)")
time.sleep(0.1)
print("I am done waiting synchronously.")
def after_change(self):
print(f"I am synchronous again. Execution took {int((time.time() - self.start_time) * 1000)} ms.")
transition = dict(trigger="start", source="Start", dest="Done", prepare="prepare_model",
before=["before_change"] * 5 + ["sync_before_change"],
after="after_change") # execute before function in asynchronously 5 times
model = AsyncModel()
machine = AsyncMachine(model, states=["Start", "Done"], transitions=[transition], initial='Start')
asyncio.get_event_loop().run_until_complete(model.start())
# >>> I am synchronous.
# I am asynchronous and will block now for 100 milliseconds.
# I am asynchronous and will block now for 100 milliseconds.
# I am asynchronous and will block now for 100 milliseconds.
# I am asynchronous and will block now for 100 milliseconds.
# I am asynchronous and will block now for 100 milliseconds.
# I am synchronous and will block the event loop (what I probably shouldn't)
# I am done waiting synchronously.
# I am done waiting.
# I am done waiting.
# I am done waiting.
# I am done waiting.
# I am done waiting.
# I am synchronous again. Execution took 101 ms.
assert model.is_Done()
```
So, why do you need to use Python 3.7 or later you may ask.
Async support has been introduced earlier.
`AsyncMachine` makes use of `contextvars` to handle running callbacks when new events arrive before a transition
has been finished:
```python
async def await_never_return():
await asyncio.sleep(100)
raise ValueError("That took too long!")
async def fix():
await m2.fix()
m1 = AsyncMachine(states=['A', 'B', 'C'], initial='A', name="m1")
m2 = AsyncMachine(states=['A', 'B', 'C'], initial='A', name="m2")
m2.add_transition(trigger='go', source='A', dest='B', before=await_never_return)
m2.add_transition(trigger='fix', source='A', dest='C')
m1.add_transition(trigger='go', source='A', dest='B', after='go')
m1.add_transition(trigger='go', source='B', dest='C', after=fix)
asyncio.get_event_loop().run_until_complete(asyncio.gather(m2.go(), m1.go()))
assert m1.state == m2.state
```
This example actually illustrates two things:
First, that 'go' called in m1's transition from `A` to be `B` is not cancelled and second, calling `m2.fix()` will
halt the transition attempt of m2 from `A` to `B` by executing 'fix' from `A` to `C`.
This separation would not be possible without `contextvars`.
Note that `prepare` and `conditions` are NOT treated as ongoing transitions.
This means that after `conditions` have been evaluated, a transition is executed even though another event already happened.
Tasks will only be cancelled when run as a `before` callback or later.
`AsyncMachine` features a model-special queue mode which can be used when `queued='model'` is passed to the constructor.
With a model-specific queue, events will only be queued when they belong to the same model.
Furthermore, a raised exception will only clear the event queue of the model that raised that exception.
For the sake of simplicity, let's assume that every event in `asyncion.gather` below is not triggered at the same time but slightly delayed:
```python
asyncio.gather(model1.event1(), model1.event2(), model2.event1())
# execution order with AsyncMachine(queued=True)
# model1.event1 -> model1.event2 -> model2.event1
# execution order with AsyncMachine(queued='model')
# (model1.event1, model2.event1) -> model1.event2
asyncio.gather(model1.event1(), model1.error(), model1.event3(), model2.event1(), model2.event2(), model2.event3())
# execution order with AsyncMachine(queued=True)
# model1.event1 -> model1.error
# execution order with AsyncMachine(queued='model')
# (model1.event1, model2.event1) -> (model1.error, model2.event2) -> model2.event3
```
Note that queue modes must not be changed after machine construction.
#### Adding features to states
If your superheroes need some custom behaviour, you can throw in some extra functionality by decorating machine states:
```python
from time import sleep
from transitions import Machine
from transitions.extensions.states import add_state_features, Tags, Timeout
@add_state_features(Tags, Timeout)
class CustomStateMachine(Machine):
pass
class SocialSuperhero(object):
def __init__(self):
self.entourage = 0
def on_enter_waiting(self):
self.entourage += 1
states = [{'name': 'preparing', 'tags': ['home', 'busy']},
{'name': 'waiting', 'timeout': 1, 'on_timeout': 'go'},
{'name': 'away'}] # The city needs us!
transitions = [['done', 'preparing', 'waiting'],
['join', 'waiting', 'waiting'], # Entering Waiting again will increase our entourage
['go', 'waiting', 'away']] # Okay, let' move
hero = SocialSuperhero()
machine = CustomStateMachine(model=hero, states=states, transitions=transitions, initial='preparing')
assert hero.state == 'preparing' # Preparing for the night shift
assert machine.get_state(hero.state).is_busy # We are at home and busy
hero.done()
assert hero.state == 'waiting' # Waiting for fellow superheroes to join us
assert hero.entourage == 1 # It's just us so far
sleep(0.7) # Waiting...
hero.join() # Weeh, we got company
sleep(0.5) # Waiting...
hero.join() # Even more company \o/
sleep(2) # Waiting...
assert hero.state == 'away' # Impatient superhero already left the building
assert machine.get_state(hero.state).is_home is False # Yupp, not at home anymore
assert hero.entourage == 3 # At least he is not alone
```
Currently, transitions comes equipped with the following state features:
* **Timeout** -- triggers an event after some time has passed
- keyword: `timeout` (int, optional) -- if passed, an entered state will timeout after `timeout` seconds
- keyword: `on_timeout` (string/callable, optional) -- will be called when timeout time has been reached
- will raise an `AttributeError` when `timeout` is set but `on_timeout` is not
- Note: A timeout is triggered in a thread. This implies several limitations (e.g. catching Exceptions raised in timeouts). Consider an event queue for more sophisticated applications.
* **Tags** -- adds tags to states
- keyword: `tags` (list, optional) -- assigns tags to a state
- `State.is_` will return `True` when the state has been tagged with `tag_name`, else `False`
* **Error** -- raises a `MachineError` when a state cannot be left
- inherits from `Tags` (if you use `Error` do not use `Tags`)
- keyword: `accepted` (bool, optional) -- marks a state as accepted
- alternatively the keyword `tags` can be passed, containing 'accepted'
- Note: Errors will only be raised if `auto_transitions` has been set to `False`. Otherwise every state can be exited with `to_` methods.
* **Volatile** -- initialises an object every time a state is entered
- keyword: `volatile` (class, optional) -- every time the state is entered an object of type class will be assigned to the model. The attribute name is defined by `hook`. If omitted, an empty VolatileObject will be created instead
- keyword: `hook` (string, default='scope') -- The model's attribute name for the temporal object.
You can write your own `State` extensions and add them the same way. Just note that `add_state_features` expects *Mixins*. This means your extension should always call the overridden methods `__init__`, `enter` and `exit`. Your extension may inherit from *State* but will also work without it.
Using `@add_state_features` has a drawback which is that decorated machines cannot be pickled (more precisely, the dynamically generated `CustomState` cannot be pickled).
This might be a reason to write a dedicated custom state class instead.
Depending on the chosen state machine, your custom state class may need to provide certain state features. For instance, `HierarchicalMachine` requires your custom state to be an instance of `NestedState` (`State` is not sufficient). To inject your states you can either assign them to your `Machine`'s class attribute `state_cls` or override `Machine.create_state` in case you need some specific procedures done whenever a state is created:
```python
from transitions import Machine, State
class MyState(State):
pass
class CustomMachine(Machine):
# Use MyState as state class
state_cls = MyState
class VerboseMachine(Machine):
# `Machine._create_state` is a class method but we can
# override it to be an instance method
def _create_state(self, *args, **kwargs):
print("Creating a new state with machine '{0}'".format(self.name))
return MyState(*args, **kwargs)
```
If you want to avoid threads in your `AsyncMachine` entirely, you can replace the `Timeout` state feature with `AsyncTimeout` from the `asyncio` extension:
```python
import asyncio
from transitions.extensions.states import add_state_features
from transitions.extensions.asyncio import AsyncTimeout, AsyncMachine
@add_state_features(AsyncTimeout)
class TimeoutMachine(AsyncMachine):
pass
states = ['A', {'name': 'B', 'timeout': 0.2, 'on_timeout': 'to_C'}, 'C']
m = TimeoutMachine(states=states, initial='A', queued=True) # see remark below
asyncio.run(asyncio.wait([m.to_B(), asyncio.sleep(0.1)]))
assert m.is_B() # timeout shouldn't be triggered
asyncio.run(asyncio.wait([m.to_B(), asyncio.sleep(0.3)]))
assert m.is_C() # now timeout should have been processed
```
You should consider passing `queued=True` to the `TimeoutMachine` constructor. This will make sure that events are processed sequentially and avoid asynchronous [racing conditions](https://github.com/pytransitions/transitions/issues/459) that may appear when timeout and event happen in close proximity.
#### Using transitions together with Django
You can have a look at the [FAQ](examples/Frequently%20asked%20questions.ipynb) for some inspiration or checkout `django-transitions`.
It has been developed by Christian Ledermann and is also hosted on [Github](https://github.com/PrimarySite/django-transitions).
[The documentation](https://django-transitions.readthedocs.io/en/latest/) contains some usage examples.
### I have a [bug report/issue/question]...
First, congratulations! You reached the end of the documentation!
If you want to try out `transitions` before you install it, you can do that in an interactive Jupyter notebook at mybinder.org.
Just click this button 👉 [](https://mybinder.org/v2/gh/pytransitions/transitions/master?filepath=examples%2FPlayground.ipynb).
For bug reports and other issues, please [open an issue](https://github.com/pytransitions/transitions) on GitHub.
For usage questions, post on Stack Overflow, making sure to tag your question with the [`pytransitions` tag](https://stackoverflow.com/questions/tagged/pytransitions). Do not forget to have a look at the [extended examples](./examples)!
For any other questions, solicitations, or large unrestricted monetary gifts, email [Tal Yarkoni](mailto:tyarkoni@gmail.com) (initial author) and/or [Alexander Neumann](mailto:aleneum@gmail.com) (current maintainer).
transitions-0.8.10+3/LICENSE 0000644 0002322 0002322 00000002112 14155650047 015671 0 ustar debalance debalance The MIT License
Copyright (c) 2014 - 2020 Tal Yarkoni, Alexander Neumann
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
transitions-0.8.10+3/.coveragerc 0000644 0002322 0002322 00000000113 14155650047 017004 0 ustar debalance debalance [run]
source = transitions
include = */transitions/*
relative_files = True
transitions-0.8.10+3/requirements.txt 0000644 0002322 0002322 00000000004 14155650047 020146 0 ustar debalance debalance six
transitions-0.8.10+3/MANIFEST.in 0000644 0002322 0002322 00000000444 14155650047 016430 0 ustar debalance debalance include *.md
include *.txt
include .coveragerc
include .pylintrc
include LICENSE
include MANIFEST
include *.ini
include conftest.py
recursive-include examples *.ipynb
recursive-include tests *.py
recursive-exclude examples/.ipynb_checkpoints *.ipynb
recursive-include binder *.txt postBuild
transitions-0.8.10+3/Changelog.md 0000644 0002322 0002322 00000063521 14155650047 017110 0 ustar debalance debalance # Changelog
## 0.8.11 ()
Release 0.8.11 is the last 0.8 release and contains fixes for Python 3.10 compatibility issues
- Bug #559: Rewrote an async test and replaced `setDaemon` with `daemon` property assignment for thread handling (thanks @debalance)
## 0.8.10 (October 2021)
Release 0.8.10 is a minor release and contains two bug fixes for the HSM extension and changes how the 'self' literal string is handled.
- Feature #545: The literal 'self' (default model parameter of `Machine`) has been replaced by the class variable `Machine.self_literal = 'self'`. `Machine` now performs an identity check (instead of a value check) with `mod is self.self_literal` to determine whether it should act as a model. While 'self' should still work when passed to the `model` parameter, we encourage using `Machine.self_literal` from now on. This was done to enable easier override of `Machine.__eq__` in subclasses (thanks @VKSolovev).
- Bug #547: Introduce `HierarchicalMachine.prefix_path` to resolve global state names since the HSM stack is not reliable when `queued=True` (thanks @jankrejci).
- Bug #548: `HSM` source states were exited even though they are parents of the destination state (thanks @wes-public-apps).
## 0.8.9 (September 2021)
Release 0.8.9 is a minor release and contains a bugfix for HSM, a feature for `GraphSupport` and changes internal cache handling:
- Bugfix #544: `NestedEvent` now wraps the machine's scope into partials passed to `HierarchicalMachine._process`. This prevents queued transitions from losing their scope.
- Feature #533: `(A)Graph.draw` function (object returned by `GraphMachine.get_graph()`) can be passed a file/stream object as first parameter or `None`. The later will result in `draw` returning a binary string. (thanks @Blindfreddy).
- Feature #532: Use id(model) instead of model for machine-bound caches in `LockedMachine`, `AsyncMachine` and `GraphMachine`. This might influence pickling (thanks @thedrow).
## 0.8.8 (April 2021)
Release 0.8.8 is a minor release and contains a bugfix and several new or improved features:
- Bugfix #526: `AsyncMachine` does not remove models when `remove_models` is called (thanks @Plazas87)
- Feature #517: Introduce `try/except` for finalize callbacks in `Machine` and `HierachicalMachine`. Thus, errors occurring in finalize callbacks will be suppressed and only the original error will be raised.
- Feature #520: Show references in graphs and markup. Introduce `MarkupMachine.format_references` to tweak reference formatting (thanks @StephenCarboni)
- Feature #485: Introduce `Machine.on_exception` to handle raised exceptions in callbacks (thanks @thedrow)
- Feature #527: `Machine.get_triggers` now supports `State` and `Enum` as arguments (thanks @luup2k)
- Feature #506: `NestedState` and `HierachicalMachine.add_states` now accept (lists of) states and enums as `initial` parameter
## 0.8.7 (February 2021)
Release 0.8.7 is a minor release and contains a bugfix, a feature and adjustments to internal processes:
- State configuration dictionaries passed to `HierarchicalMachine` can also use `states` as a keyword to define substates. If `children` and `states` are present, only `children` will be considered.
- Feature #500: `HierarchicalMachine` with custom separator now adds `is_state` partials for nested states (e.g. `is_C.s3.a()`) to models (thanks @alterscape)
- Bugfix #512: Use `model_attribute` consistently in `AsyncMachine` (thanks @thedrow)
- Testing now treats most warnings as errors (thanks @thedrow)
- As a consequence, `pygraphviz.Agraph` in `diagrams_pygraphviz` are now copied by `transitions` since `AGraph.copy` as of version `1.6` does not close temporary files appropriately
- `HierarchicalMachine` now checks whether `state_cls`, `event_cls` and `transition_cls` have been subclassed from nested base classes (e.g. `NestedState`) to prevent hard to debug inheritance errors
## 0.8.6 (December 2020)
Release 0.8.6 is a minor release and contains bugfixes and new features:
- `HierarchicalMachine.add_states` will raise a `ValueError` when an `Enum` name contains the currently used `NestedState.separator`.
- Bugfix #486: Reset `NestedState._scope` when enter/exit callbacks raise an exception (thanks @m986883511)
- Bugfix #488: Let `HierarchicalMachine._get_trigger` which is bound to `model.trigger` raise a `MachineError` for invalid events and `AttributeError` for unknown events (thanks @hsharrison)
- Introduced `HierarchicalMachine.has_trigger` to determine whether an event is valid for an HSM
- Feature #490: `AsyncMachine` features an event queue dictionary for individual models when `queued='model'` (thanks @jekel)
- Feature #490: `Machine.remove_model` will now also remove model events from the event queue when `queued=True`
- Feature #491: `Machine.get_transitions` and its HSM counterpart now accept `Enum` and `State` for `source` and `dest` (thanks @thedrow)
## 0.8.5 (November 2020)
Release 0.8.5 is a minor release and contains bugfixes:
- `AsyncMachine.switch_model_context` is expected to be `async` now for easier integration of async code during model switch.
- Bugfix #478: Initializing a machine with `GraphSupport` threw an exception when initial was set to a nested or parallel state (thanks @nickvazztau)
## 0.8.4 (October 2020)
Release 0.8.4 is a minor release and contains bugfixes as well as new features:
- Bugfix #477: Model callbacks were not added to a LockedHierarchicalMachine when the machine itself served as a model (thanks @oliver-goetz)
- Bugfix #475: Clear collection of tasks to prevent memory leak when initializing many models (thanks @h-nakai)
- Feature #474: Added static `AsyncMachine.protected_tasks` list which can be used to prevent `transitions` to cancel certain tasks.
- Feature: Constructor of `HierarchicalMachine` now accepts substates ('A_1_c') and parallel states (['A', 'B']) as `initial` parameter
## 0.8.3 (September 2020)
Release 0.8.3 is a minor release and contains several bugfixes mostly related to `HierarchicalStateMachine`:
- Feature #473: Assign `is__` instead of `is_` when `model_attribute != "state"` to enable multiple versions of such convenience functions. A warning will be raised when `is_` is used. (thanks @artofhuman)
- Similarly, auto transitions (`to_`) will be assigned as `to__`. `to_` will work as before but raise a warning until version 0.9.0.
- Bugfix: `allow_substates` did not consider enum states
- Feature: Nested enums can now be passed in a dict as `children` with `initial` parameter
- Bugfix #449: get_triggers/get_transitions did not return nested triggers correctly (thanks @alexandretanem)
- Feature #452: Improve handling of label attributes in custom diagram states and `TransitionGraphSupport` (thanks @badiku)
- Bugfix #456: Prevent parents from overriding (falsy) results of their children's events (thanks @alexandretanem)
- Bugfix #458: Entering the same state caused key errors when transition was defined on a parent (thanks @matlom)
- Bugfix #459: Do not remove current timeout runner in AsyncTimeout to prevent accidental overrides (thanks @rgov)
- Rewording of `State.enter/exit` debug message emitted when callbacks have been processed.
- Bugfix #370: Fix order of `before_state_change/before` and `after/after_state_change` in `AsyncMachine` (thanks @tzoiker and @vishes-shell)
- Bugfix #470: `Graph.get_graph()` did not consider `enum` states when `show_roi=True` (thanks @termim)
## 0.8.2 (June 2020)
Release 0.8.2 is a minor release and contains several bugfixes and improvements:
- Bugfix #438: Improved testing without any optional `graphviz` package
- Bugfix: `_check_event_result` failed when model was in parallel state
- Bugfix #440: Only allow explicit `dest=None` in `Machine.add_transition` (not just falsy) for internal transitions (thanks @Pathfinder216)
- Bugfix #419: Fix state creation of nested enums (thanks @thedrow)
- Bugfix #428: HierarchicalGraphMachine did not find/apply styling for parallel states (thanks @xiaohuihui1024)
- Bugfix: `Model.trigger` now considers the machine's and current state's `ignore_invalid_triggers` attribute and can be called with non-existing events (thanks @potens1)
- Bugfix: Child states may not have been exited when the executed transition had been defined on a parent (thanks @thedrow)
- Feature #429: Introduced `transitions.extensions.asyncio.AsyncTimeout` as a state decorator to avoid threads used in `transitions.extensions.state.Timeout` (thanks @potens1)
- Feature #444: `transitions` can now be tested online at mybinder.org
- PR #418: Use sets instead of lists to cache already covered transitions in nested state machines (thanks @thedrow)
- PR #422: Improve handling of unresolved attributes for easier inheritance (thanks @thedrow)
- PR #445: Refactored AsyncMachine to enable trio/anyio override
## 0.8.1 (April 2020)
Release 0.8.1 is a minor release of HSM improvements and bugfixes in the diagram and async extension:
- Feature: Introduced experimental `HierarchicalAsync(Graph)Machine`
- Feature #405: Support for nested Enums in `HierarchicalMachine` (thanks @thedrow)
- Bugfix #400: Fix style initialization when initial state is an `Enum` (thanks @kbinpgh)
- Bugfix #403: AsyncMachine.dispatch now returns a boolean as expected (thanks @thedrow)
- Bugfix #413: Improve diagram output for `HierarchicalMachine` (thanks @xiaohuihui1024)
- Increased coverage (thanks @thedrow)
- Introduced `xdist` for parallel testing with `pytest` (thanks @thedrow)
## 0.8.0 (March 2020)
Release 0.8.0 is a major release and introduces asyncio support for Python 3.7+, parallel state support and some bugfixes:
- Feature: `HierarchicalMachine` has been rewritten to support parallel states. Please have a look at the ReadMe.md to check what has changed.
- The previous version can be found in `transitions.extensions.nesting_legacy` for now
- Feature: Introduced `AsyncMachine` (see discussion #259); note that async HSMs are not yet supported
- Feature #390: String callbacks can now point to properties and attributes (thanks @jsenecal)
- Bugfix: Auto transitions are added multiple times when add_states is called more than once
- Bugfix: Convert state.\_name from `Enum` into strings in `MarkupMachine` when necessary
- Bugfix #392: Allow `Machine.add_ordered_transitions` to be called without the initial state (thanks @mkaranki and @facundofc)
- `GraphMachine` now attempts to fall back to `graphviz` when importing `pygraphviz` fails
- Not implemented/tested so far (contributions are welcome!):
- Proper Graphviz support of parallel states
- AsyncHierachicalMachine
## 0.7.2 (January 2020)
Release 0.7.2 is a minor release and contains bugfixes and a new feature:
- Bugfix #386: Fix transitions for enums with str behavior (thanks @artofhuman)
- Bugfix #378: Don't mask away KeyError when executing a transition (thanks @facundofc)
- Feature #387: Add support for dynamic model state attribute (thanks @v1k45)
## 0.7.1 (September 2019)
Release 0.7.1 is a minor release and contains several documentation improvements and a new feature:
- Feature #334: Added Enum (Python 3.4+: `enum` Python 2.7: `enum34`) support (thanks @artofhuman and @justinttl)
- Replaced test framework `nosetests` with `pytest` (thanks @artofhuman)
- Extended `add_ordered_transitions` documentation in `Readme.md`
- Collected code snippets from earlier discussions in `examples/Frequently asked questions.ipynb`
- Improved stripping of `long_description` in `setup.py` (thanks @artofhuman)
## 0.7.0 (August 2019)
Release 0.7.0 is a major release with fundamental changes to the diagram extension. It also introduces an intermediate `MarkupMachine` which can be used to transfer and (re-)initialize machine configurations.
- Feature #263: `MarkupMachine` can be used to retrieve a Machine's dictionary representation
- `GraphMachine` uses this representation for Graphs now and does not rely on `Machine` attributes any longer
- Feature: The default value of `State.ignore_invalid_triggers` changed to `None`. If it is not explicitly set, the `Machine`'s value is used instead.
- Feature #325: transitions now supports `pygraphviz` and `graphviz` for the creation of diagrams. Currently, `GraphMachine` will check for `pygraphviz` first and fall back to `graphviz`. To use `graphviz` directly pass `use_pygraphiv=False` to the constructor of `GraphMachine`
- Diagram style has been overhauled. Have a look at `GraphMachine`'s attributes `machine_attributes` and `style_attributes` to adjust it to your needs.
- Feature #305: Timeouts and other features are now marked in the graphs
- Bugfix #343: `get_graph` was not assigned to models added during machine runtime
## 0.6.9 (October 2018)
Release 0.6.9 is a minor release and contains two bugfixes:
- Bugfix #314: Do not override already defined model functions with convenience functions (thanks @Arkanayan)
- Bugfix #316: `state.Error` did not call parent's `enter` method (thanks @potens1)
## 0.6.8 (May, 2018)
Release 0.6.8 is a minor release and contains a critical bugfix:
- Bugfix #301: Reading `Readme.md` in `setup.py` causes a `UnicodeDecodeError` in non-UTF8-locale environments (thanks @jodal)
## 0.6.7 (May, 2018)
Release 0.6.7 is identical to 0.6.6. A release had been necessary due to #294 related to PyPI.
## 0.6.6 (May, 2018)
Release 0.6.6 is a minor release and contains several bugfixes and new features:
- Bugfix: `HierarchicalMachine` now considers the initial state of `NestedState` instances/names passed to `initial`.
- Bugfix: `HierarchicalMachine` used to ignore children when `NestedStates` were added to the machine.
- Bugfix #300: Fixed missing brackets in `TimeoutState` (thanks @Synss)
- Feature #289: Introduced `Machine.resolve_callable(func, event_data)` to enable customization of callback definitions (thanks @ollamh and @paulbovbel)
- Feature #299: Added support for internal transitions with `dest=None` (thanks @maueki)
- Feature: Added `Machine.dispatch` to trigger events on all models assigned to `Machine`
## 0.6.5 (April, 2018)
Release 0.6.5 is a minor release and contains a new feature and a bugfix:
- Feature #287: Embedding `HierarchicalMachine` will now reuse the machine's `initial` state. Passing `initial: False` overrides this (thanks @mrjogo).
- Bugfix #292: Models using `GraphMashine` were not picklable in the past due to `graph` property. Graphs for each model are now stored in `GraphMachine.model_graphs` (thanks @ansumanm).
## 0.6.4 (January, 2018)
Release 0.6.4 is a minor release and contains a new feature and two bug fixes related to `HierachicalMachine`:
- Bugfix #274: `initial` has not been passed to super in `HierachicalMachine.add_model` (thanks to @illes).
- Feature #275: `HierarchicalMachine.add_states` now supports keyword `parent` to be a `NestedState` or a string.
- Bugfix #278: `NestedState` has not been exited correctly during reflexive triggering (thanks to @hrsmanian).
## 0.6.3 (November, 2017)
Release 0.6.3 is a minor release and contains a new feature and two bug fixes:
- Bugfix #268: `Machine.add_ordered_transitions` changed states' order if `initial` is not the first or last state (thanks to @janekbaraniewski).
- Bugfix #265: Renamed `HierarchicalMachine.to` to `to_state` to prevent warnings when HSM is used as a model.
- Feature #266: Introduce `Machine.get_transitions` to get a list of transitions for alteration (thanks to @Synss).
## 0.6.2 (November, 2017)
Release 0.6.2 is a minor release and contains new features and bug fixes but also several internal changes:
- Documentation: Add docstring to every public method
- Bugfix #257: Readme example variable had been capitalized (thanks to @fedesismo)
- Add `appveyor.yml` for Windows testing; However, Windows testing is disabled due to #258
- Bugfix #262: Timeout threads prevented program from execution when main thread ended (thanks to @tkuester)
- `prep_ordered_arg` is now protected in `core`
- Convert `logger` instances to `_LOGGER` to comply with protected module constant naming standards
- `traverse` is now protected in `HierarchicalMachine`
- Remove abstract class `Diagram` since it did not add functionality to `diagrams`
- Specify several overrides of `add_state` or `add_transition` to keep the base class parameters instead of `*args` and `**kwargs`
- Change several `if len(x) > 0:` checks to `if x:` as suggested by the static code analysis to make use of falsy empty lists/strings.
## 0.6.1 (September, 2017)
Release 0.6.1 is a minor release and contains new features as well as bug fixes:
- Feature #245: Callback definitions ('before', 'on_enter', ...) have been moved to classes `Transition` and `State`
- Bugfix #253: `Machine.remove_transitions` converted `defaultdict` into dict (thanks @Synss)
- Bugfix #248: `HierarchicalStateMachine`'s copy procedure used to cause issues with function callbacks and object references (thanks @Grey-Bit)
- Renamed `Machine.id` to `Machine.name` to be consistent with the constructor parameter `name`
- Add `Machine.add_transitions` for adding multiple transitions at once (thanks @Synss)
## 0.6.0 (August, 2017)
Release 0.6.0 is a major release and introduces new state features and bug fixes:
- `add_state_features` convenience decorator supports creation of custom states
- `Tags` makes states taggable
- `Error` checks for error states (not accepted states that cannot be left); subclass of `Tags`
- `Volatile` enables scoped/temporary state objects to handle context parameters
- Removed `add_self` from `Machine` constructor
- `pygraphviz` is now optional; use `pip install transitions[diagrams]` to install it
- Narrowed warnings filter to prevent output cluttering by other 3rd party modules (thanks to @ksandeep)
- Reword HSM exception when wrong state object had been passedn (thanks to @Blindfreddy)
- Improved handling of partials during graph generation (thanks to @Synss)
- Introduced check to allow explicit passing of callback functions which match the `on_enter_` scheme (thanks to @termim)
- Bug #243: on_enter/exit callbacks defined in dictionaries had not been assigned correctly in HSMs (thanks to @Blindfreddy)
- Introduced workaround for Python 3 versions older than 3.4 to support dill version 0.2.7 and higher (thanks to @mmckerns)
- Improved manifest (#242) to comply with distribution standards (thanks to @jodal)
## 0.5.3 (May, 2017)
Release 0.5.3 is a minor release and contains several bug fixes:
- Bug #214: `LockedMachine` as a model prevented correct addition of `on_enter/exit_` (thanks to @kr2)
- Bug #217: Filtering rules for auto transitions in graphs falsely filtered certain transitions (thanks to @KarolOlko)
- Bug #218: Uninitialized `EventData.transition` caused `AttributeError` in `EventData.__repr__` (thanks to @kunalbhagawati)
- Bug #215: State instances passed to `initial` parameter of `Machine` constructor had not been processed properly (thanks @mathiasimmer)
## 0.5.2 (April, 2017)
Release 0.5.2 is a minor release and contains a bug fix:
- Bug #213: prevent `LICENSE` to be installed to root of installation path
## 0.5.1 (April, 2017)
Release 0.5.1 is a minor release and contains new features and bug fixes:
- Added reflexive transitions (thanks to @janLo)
- Wildcards for reflexive (`wildcard_same`) and all (`wildcard_all`) destinations are `Machine` class variables now which can be altered if necessary.
- Add LICENSE to packaged distribution (thanks to @bachp)
- Bug #211: `prepare` and `finalized` had not been called for HierarchicalMachines (thanks to @booware)
## 0.5.0 (March, 2017)
Release 0.5.0 is a major release:
- CHANGED API: `MachineError` is now limited to internal error and has been replaced by `AttributeError` and `ValueError` where applicable (thanks to @ankostis)
- CHANGED API: Phasing out `add_self`; `model=None` will add NO model starting from next major release; use `model='self'` instead.
- Introduced deprecation warnings for upcoming changes concerning `Machine` keywords `model` and `add_self`
- Introduced `Machine.remove_transition` (thanks to @PaleNeutron)
- Introduced `Machine._create_state` for easier subclassing of states
- `LockedMachine` now supports custom context managers for each model (thanks to @paulbovbel)
- `Machine.before/after_state_change` can now be altered dynamically (thanks to @peendebak)
- `Machine.add_ordered_transitions` now supports `prepare`, `conditons`, `unless`, `before` and `after` (thanks to @aforren1)
- New `prepare_event` and `finalize_event` keywords to handle transitions globally (thanks to @ankostis)
- New `show_auto_transitions` keyword for `GraphMachine.__init__` (default `False`); if enabled, show auto transitions in graph
- New `show_roi` keyword for `GraphMachine._get_graph` (default `False`); if `True`, show only reachable states in retrieved graph
- Test suite now skips contextual tests (e.g. pygraphviz) if dependencies cannot be found (thanks to @ankostis)
- Improved string representation of several classes (thanks to @ankostis)
- Improved `LockedMachine` performance by removing recursive locking
- Improved graph layout for nested graphs
- `transitions.extensions.nesting.AGraph` has been split up into `Graph` and `NestedGraph` for easier maintenance
- Fixed bug related to pickling `RLock` in nesting
- Fixed order of callback execution (thanks to @ankostis)
- Fixed representation of condition names in graphs (thanks to @cemoody)
## 0.4.3 (December, 2016)
Release 0.4.3 is a minor release and contains bug fixes and several new features:
- Support dynamic model addition via `Machine.add_model` (thanks to @paulbovbel)
- Allow user to explicitly pass a lock instance or context manager to LockedMachine (thanks to @paulbovbel)
- Fixed issue related to parsing of HSMs (thanks to @steval and @user2154065 from SO)
- When `State` is passed to `Machine.add_transition`, it will check if the state (and not just the name) is known to the machine
## 0.4.2 (October, 2016)
Release 0.4.2 contains several new features and bugfixes:
- Machines can work with multiple models now (thanks to @gemerden)
- New `initial` keyword for nested states to automatically enter a child
- New `Machine.trigger` method to trigger events by name (thanks to @IwanLD)
- Bug fixes related to remapping in nested (thanks to @imbaczek)
- Log messages in `Transition.execute` and `Machine.__init__` have been reassigned to DEBUG log level (thanks to @ankostis)
- New `Machine.get_triggers` method to return all valid transitions from (a) certain state(s) (thanks to @limdauto and @guilhermecgs)
## 0.4.1 (July, 2016)
Release 0.4.1 is a minor release containing bug fixes, minor API changes, and community feedback:
- `async` is renamed to `queued` since it describes the mechanism better
- HierarchicalStateMachine.is_state now provides `allow_substates` as an optional argument(thanks to @jonathanunderwood)
- Machine can now be used in scenarios where multiple inheritance is required (thanks to @jonathanunderwood)
- Adds support for tox (thanks to @medecau and @aisbaa)
- Bug fixes:
- Problems with conditions shown multiple times in graphs
- Bug which omitted transitions with same source and destination in diagrams (thanks to @aisbaa)
- Conditions passed incorrectly when HSMs are used as a nested state
- Class nesting issue that prevented pickling with dill
- Two bugs in HierarchicalStateMachine (thanks to @ajax2leet)
- Avoided recursion error when naming a transition 'process' (thanks to @dceresuela)
- Minor PEP8 fixes (thanks to @medecau)
## 0.4.0 (April, 2016)
Release 0.4 is a major release that includes several new features:
- New `async` Machine keyword allows queueing of transitions (thanks to @khigia)
- New `name` Machine keyword customizes transitions logger output for easier debugging of multiple running instances
- New `prepare` Transition keyword for callbacks before any 'conditions' are checked (thanks to @TheMysteriousX)
- New `show_conditions` GraphSupport keyword adds condition checks to dot graph edges (thanks to @khigia)
- Nesting now supports custom (unicode) substate separators
- Nesting no longer requires a leaf state (e.g. to_C() does not enter C_1 automatically)
- Factory for convenient extension mixins
- Numerous minor improvements and bug fixes
## 0.3.1 (January 3, 2016)
Mostly a bug fix release. Changes include:
- Fixes graphing bug introduced in 0.3.0 (thanks to @wtgee)
- Fixes bug in dynamic addition of before/after callbacks (though this is a currently undocumented feature)
- Adds coveralls support and badge
- Adds a few tests to achieve near-100% coverage
## 0.3.0 (January 2, 2016)
Release 0.3 includes a number of new features (nesting, multithreading, and graphing) as well as bug fixes and minor improvements:
- Support for nested states (thanks to @aleneum)
- Basic multithreading support for function access (thanks to @aleneum)
- Basic graphing support via graphviz (thanks to @svdgraaf)
- Stylistic edits, minor fixes, and improvements to README
- Expanded and refactored tests
- Minor bug fixes
## 0.2.9 (November 10, 2015)
- Enabled pickling in Python 3.4 (and in < 3.4 with the dill module)
- Added reference to generating Transition in EventData objects
- Fixed minor bugs
## 0.2.8 (August, 6, 2015)
- README improvements, added TOC, and typo fixes
- Condition checks now receive optional data
- Removed invasive basicConfig() call introduced with logging in 0.2.6
## 0.2.7 (July 27, 2015)
- Fixed import bug that prevented dependency installation at setup
## 0.2.6 (July 26, 2015)
- Added rudimentary logging for key transition and state change events
- Added generic before/after callbacks that apply to all state changes
- Ensured string type compatibility across Python 2 and 3
## 0.2.5 (May 4, 2015)
- Added ability to suppress invalid trigger calls
- Shorthand definition of transitions via lists
## 0.2.4 (March 11, 2015)
- Automatic detection of predefined state callbacks
- Fixed bug in automatic transition creation
- Added Changelog
## 0.2.3 (January 14, 2015)
- Added travis-ci support
- Cleaned up and PEP8fied code
- Added 'unless' argument to transitions that mirrors 'conditions'
## 0.2.2 (December 28, 2014)
- Python 2/3 compatibility
- Added automatic to\_{state}() methods
- Added ability to easily add ordered transitions
transitions-0.8.10+3/requirements_diagrams.txt 0000644 0002322 0002322 00000000013 14155650047 022015 0 ustar debalance debalance pygraphviz
transitions-0.8.10+3/transitions/ 0000755 0002322 0002322 00000000000 14155650047 017245 5 ustar debalance debalance transitions-0.8.10+3/transitions/__init__.py 0000644 0002322 0002322 00000001001 14155650047 021346 0 ustar debalance debalance """
transitions
-----------
A lightweight, object-oriented state machine implementation in Python. Compatible with Python 2.7+ and 3.0+.
"""
from __future__ import absolute_import
from .version import __version__
from .core import (State, Transition, Event, EventData, Machine, MachineError)
__copyright__ = "Copyright (c) 2021 Tal Yarkoni, Alexander Neumann"
__license__ = "MIT"
__summary__ = "A lightweight, object-oriented finite state machine in Python"
__uri__ = "https://github.com/tyarkoni/transitions"
transitions-0.8.10+3/transitions/version.py 0000644 0002322 0002322 00000000260 14155650047 021302 0 ustar debalance debalance """ Contains the current version of transition which is used in setup.py and can also be used
to determine transitions' version during runtime.
"""
__version__ = '0.8.10'
transitions-0.8.10+3/transitions/core.py 0000644 0002322 0002322 00000165603 14155650047 020562 0 ustar debalance debalance """
transitions.core
----------------
This module contains the central parts of transitions which are the state machine logic, state
and transition concepts.
"""
try:
from builtins import object
except ImportError:
# python2
pass
try:
# Enums are supported for Python 3.4+ and Python 2.7 with enum34 package installed
from enum import Enum, EnumMeta
except ImportError:
# If enum is not available, create dummy classes for type checks
class Enum:
pass
class EnumMeta:
pass
import inspect
import itertools
import logging
from collections import OrderedDict, defaultdict, deque
from functools import partial
from six import string_types
import warnings
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
warnings.filterwarnings(action='default', message=r".*transitions version.*", category=DeprecationWarning)
def listify(obj):
"""Wraps a passed object into a list in case it has not been a list, tuple before.
Returns an empty list in case ``obj`` is None.
Args:
obj: instance to be converted into a list.
Returns:
list: May also return a tuple in case ``obj`` has been a tuple before.
"""
if obj is None:
return []
try:
return obj if isinstance(obj, (list, tuple, EnumMeta)) else [obj]
except ReferenceError:
# obj is an empty weakref
return [obj]
def _prep_ordered_arg(desired_length, arguments=None):
"""Ensure list of arguments passed to add_ordered_transitions has the proper length.
Expands the given arguments and apply same condition, callback
to all transitions if only one has been given.
Args:
desired_length (int): The size of the resulting list
arguments (optional[str, reference or list]): Parameters to be expanded.
Returns:
list: Parameter sets with the desired length.
"""
arguments = listify(arguments) if arguments is not None else [None]
if len(arguments) != desired_length and len(arguments) != 1:
raise ValueError("Argument length must be either 1 or the same length as "
"the number of transitions.")
if len(arguments) == 1:
return arguments * desired_length
return arguments
class State(object):
"""A persistent representation of a state managed by a ``Machine``.
Attributes:
name (str): State name which is also assigned to the model(s).
on_enter (list): Callbacks executed when a state is entered.
on_exit (list): Callbacks executed when a state is exited.
ignore_invalid_triggers (bool): Indicates if unhandled/invalid triggers should raise an exception.
"""
# A list of dynamic methods which can be resolved by a ``Machine`` instance for convenience functions.
# Dynamic methods for states must always start with `on_`!
dynamic_methods = ['on_enter', 'on_exit']
def __init__(self, name, on_enter=None, on_exit=None,
ignore_invalid_triggers=None):
"""
Args:
name (str or Enum): The name of the state
on_enter (str or list): Optional callable(s) to trigger when a
state is entered. Can be either a string providing the name of
a callable, or a list of strings.
on_exit (str or list): Optional callable(s) to trigger when a
state is exited. Can be either a string providing the name of a
callable, or a list of strings.
ignore_invalid_triggers (Boolean): Optional flag to indicate if
unhandled/invalid triggers should raise an exception
"""
self._name = name
self.ignore_invalid_triggers = ignore_invalid_triggers
self.on_enter = listify(on_enter) if on_enter else []
self.on_exit = listify(on_exit) if on_exit else []
@property
def name(self):
if isinstance(self._name, Enum):
return self._name.name
else:
return self._name
@property
def value(self):
return self._name
def enter(self, event_data):
""" Triggered when a state is entered. """
_LOGGER.debug("%sEntering state %s. Processing callbacks...", event_data.machine.name, self.name)
event_data.machine.callbacks(self.on_enter, event_data)
_LOGGER.info("%sFinished processing state %s enter callbacks.", event_data.machine.name, self.name)
def exit(self, event_data):
""" Triggered when a state is exited. """
_LOGGER.debug("%sExiting state %s. Processing callbacks...", event_data.machine.name, self.name)
event_data.machine.callbacks(self.on_exit, event_data)
_LOGGER.info("%sFinished processing state %s exit callbacks.", event_data.machine.name, self.name)
def add_callback(self, trigger, func):
""" Add a new enter or exit callback.
Args:
trigger (str): The type of triggering event. Must be one of
'enter' or 'exit'.
func (str): The name of the callback function.
"""
callback_list = getattr(self, 'on_' + trigger)
callback_list.append(func)
def __repr__(self):
return "<%s('%s')@%s>" % (type(self).__name__, self.name, id(self))
class Condition(object):
""" A helper class to call condition checks in the intended way.
Attributes:
func (callable): The function to call for the condition check
target (bool): Indicates the target state--i.e., when True,
the condition-checking callback should return True to pass,
and when False, the callback should return False to pass.
"""
def __init__(self, func, target=True):
"""
Args:
func (str): Name of the condition-checking callable
target (bool): Indicates the target state--i.e., when True,
the condition-checking callback should return True to pass,
and when False, the callback should return False to pass.
Notes:
This class should not be initialized or called from outside a
Transition instance, and exists at module level (rather than
nesting under the transition class) only because of a bug in
dill that prevents serialization under Python 2.7.
"""
self.func = func
self.target = target
def check(self, event_data):
""" Check whether the condition passes.
Args:
event_data (EventData): An EventData instance to pass to the
condition (if event sending is enabled) or to extract arguments
from (if event sending is disabled). Also contains the data
model attached to the current machine which is used to invoke
the condition.
"""
predicate = event_data.machine.resolve_callable(self.func, event_data)
if event_data.machine.send_event:
return predicate(event_data) == self.target
return predicate(*event_data.args, **event_data.kwargs) == self.target
def __repr__(self):
return "<%s(%s)@%s>" % (type(self).__name__, self.func, id(self))
class Transition(object):
""" Representation of a transition managed by a ``Machine`` instance.
Attributes:
source (str): Source state of the transition.
dest (str): Destination state of the transition.
prepare (list): Callbacks executed before conditions checks.
conditions (list): Callbacks evaluated to determine if
the transition should be executed.
before (list): Callbacks executed before the transition is executed
but only if condition checks have been successful.
after (list): Callbacks executed after the transition is executed
but only if condition checks have been successful.
"""
dynamic_methods = ['before', 'after', 'prepare']
""" A list of dynamic methods which can be resolved by a ``Machine`` instance for convenience functions. """
condition_cls = Condition
""" The class used to wrap condition checks. Can be replaced to alter condition resolution behaviour
(e.g. OR instead of AND for 'conditions' or AND instead of OR for 'unless') """
def __init__(self, source, dest, conditions=None, unless=None, before=None,
after=None, prepare=None):
"""
Args:
source (str): The name of the source State.
dest (str): The name of the destination State.
conditions (optional[str, callable or list]): Condition(s) that must pass in order for
the transition to take place. Either a string providing the
name of a callable, or a list of callables. For the transition
to occur, ALL callables must return True.
unless (optional[str, callable or list]): Condition(s) that must return False in order
for the transition to occur. Behaves just like conditions arg
otherwise.
before (optional[str, callable or list]): callbacks to trigger before the
transition.
after (optional[str, callable or list]): callbacks to trigger after the transition.
prepare (optional[str, callable or list]): callbacks to trigger before conditions are checked
"""
self.source = source
self.dest = dest
self.prepare = [] if prepare is None else listify(prepare)
self.before = [] if before is None else listify(before)
self.after = [] if after is None else listify(after)
self.conditions = []
if conditions is not None:
for cond in listify(conditions):
self.conditions.append(self.condition_cls(cond))
if unless is not None:
for cond in listify(unless):
self.conditions.append(self.condition_cls(cond, target=False))
def _eval_conditions(self, event_data):
for cond in self.conditions:
if not cond.check(event_data):
_LOGGER.debug("%sTransition condition failed: %s() does not return %s. Transition halted.",
event_data.machine.name, cond.func, cond.target)
return False
return True
def execute(self, event_data):
""" Execute the transition.
Args:
event_data: An instance of class EventData.
Returns: boolean indicating whether or not the transition was
successfully executed (True if successful, False if not).
"""
_LOGGER.debug("%sInitiating transition from state %s to state %s...",
event_data.machine.name, self.source, self.dest)
event_data.machine.callbacks(self.prepare, event_data)
_LOGGER.debug("%sExecuted callbacks before conditions.", event_data.machine.name)
if not self._eval_conditions(event_data):
return False
event_data.machine.callbacks(itertools.chain(event_data.machine.before_state_change, self.before), event_data)
_LOGGER.debug("%sExecuted callback before transition.", event_data.machine.name)
if self.dest: # if self.dest is None this is an internal transition with no actual state change
self._change_state(event_data)
event_data.machine.callbacks(itertools.chain(self.after, event_data.machine.after_state_change), event_data)
_LOGGER.debug("%sExecuted callback after transition.", event_data.machine.name)
return True
def _change_state(self, event_data):
event_data.machine.get_state(self.source).exit(event_data)
event_data.machine.set_state(self.dest, event_data.model)
event_data.update(getattr(event_data.model, event_data.machine.model_attribute))
event_data.machine.get_state(self.dest).enter(event_data)
def add_callback(self, trigger, func):
""" Add a new before, after, or prepare callback.
Args:
trigger (str): The type of triggering event. Must be one of
'before', 'after' or 'prepare'.
func (str): The name of the callback function.
"""
callback_list = getattr(self, trigger)
callback_list.append(func)
def __repr__(self):
return "<%s('%s', '%s')@%s>" % (type(self).__name__,
self.source, self.dest, id(self))
class EventData(object):
""" Collection of relevant data related to the ongoing transition attempt.
Attributes:
state (State): The State from which the Event was triggered.
event (Event): The triggering Event.
machine (Machine): The current Machine instance.
model (object): The model/object the machine is bound to.
args (list): Optional positional arguments from trigger method
to store internally for possible later use.
kwargs (dict): Optional keyword arguments from trigger method
to store internally for possible later use.
transition (Transition): Currently active transition. Will be assigned during triggering.
error (Error): In case a triggered event causes an Error, it is assigned here and passed on.
result (bool): True in case a transition has been successful, False otherwise.
"""
def __init__(self, state, event, machine, model, args, kwargs):
"""
Args:
state (State): The State from which the Event was triggered.
event (Event): The triggering Event.
machine (Machine): The current Machine instance.
model (object): The model/object the machine is bound to.
args (tuple): Optional positional arguments from trigger method
to store internally for possible later use.
kwargs (dict): Optional keyword arguments from trigger method
to store internally for possible later use.
"""
self.state = state
self.event = event
self.machine = machine
self.model = model
self.args = args
self.kwargs = kwargs
self.transition = None
self.error = None
self.result = False
def update(self, state):
""" Updates the EventData object with the passed state.
Attributes:
state (State, str or Enum): The state object, enum member or string to assign to EventData.
"""
if not isinstance(state, State):
self.state = self.machine.get_state(state)
def __repr__(self):
return "<%s('%s', %s)@%s>" % (type(self).__name__, self.state,
getattr(self, 'transition'), id(self))
class Event(object):
""" A collection of transitions assigned to the same trigger
"""
def __init__(self, name, machine):
"""
Args:
name (str): The name of the event, which is also the name of the
triggering callable (e.g., 'advance' implies an advance()
method).
machine (Machine): The current Machine instance.
"""
self.name = name
self.machine = machine
self.transitions = defaultdict(list)
def add_transition(self, transition):
""" Add a transition to the list of potential transitions.
Args:
transition (Transition): The Transition instance to add to the
list.
"""
self.transitions[transition.source].append(transition)
def trigger(self, model, *args, **kwargs):
""" Executes all transitions that match the current state,
halting as soon as one successfully completes. More precisely, it prepares a partial
of the internal ``_trigger`` function, passes this to ``Machine._process``.
It is up to the machine's configuration of the Event whether processing happens queued (sequentially) or
whether further Events are processed as they occur.
Args:
model (object): The currently processed model
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
func = partial(self._trigger, model, *args, **kwargs)
# pylint: disable=protected-access
# noinspection PyProtectedMember
# Machine._process should not be called somewhere else. That's why it should not be exposed
# to Machine users.
return self.machine._process(func)
def _trigger(self, model, *args, **kwargs):
""" Internal trigger function called by the ``Machine`` instance. This should not
be called directly but via the public method ``Machine.process``.
Args:
model (object): The currently processed model
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
state = self.machine.get_model_state(model)
if state.name not in self.transitions:
msg = "%sCan't trigger event %s from state %s!" % (self.machine.name, self.name,
state.name)
ignore = state.ignore_invalid_triggers if state.ignore_invalid_triggers is not None \
else self.machine.ignore_invalid_triggers
if ignore:
_LOGGER.warning(msg)
return False
else:
raise MachineError(msg)
event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs)
return self._process(event_data)
def _process(self, event_data):
self.machine.callbacks(self.machine.prepare_event, event_data)
_LOGGER.debug("%sExecuted machine preparation callbacks before conditions.", self.machine.name)
try:
for trans in self.transitions[event_data.state.name]:
event_data.transition = trans
if trans.execute(event_data):
event_data.result = True
break
except Exception as err:
event_data.error = err
if self.machine.on_exception:
self.machine.callbacks(self.machine.on_exception, event_data)
else:
raise
finally:
try:
self.machine.callbacks(self.machine.finalize_event, event_data)
_LOGGER.debug("%sExecuted machine finalize callbacks", self.machine.name)
except Exception as err:
_LOGGER.error("%sWhile executing finalize callbacks a %s occurred: %s.",
self.machine.name,
type(err).__name__,
str(err))
return event_data.result
def __repr__(self):
return "<%s('%s')@%s>" % (type(self).__name__, self.name, id(self))
def add_callback(self, trigger, func):
""" Add a new before or after callback to all available transitions.
Args:
trigger (str): The type of triggering event. Must be one of
'before', 'after' or 'prepare'.
func (str): The name of the callback function.
"""
for trans in itertools.chain(*self.transitions.values()):
trans.add_callback(trigger, func)
class Machine(object):
""" Machine manages states, transitions and models. In case it is initialized without a specific model
(or specifically no model), it will also act as a model itself. Machine takes also care of decorating
models with conveniences functions related to added transitions and states during runtime.
Attributes:
states (OrderedDict): Collection of all registered states.
events (dict): Collection of transitions ordered by trigger/event.
models (list): List of models attached to the machine.
initial (str): Name of the initial state for new models.
prepare_event (list): Callbacks executed when an event is triggered.
before_state_change (list): Callbacks executed after condition checks but before transition is conducted.
Callbacks will be executed BEFORE the custom callbacks assigned to the transition.
after_state_change (list): Callbacks executed after the transition has been conducted.
Callbacks will be executed AFTER the custom callbacks assigned to the transition.
finalize_event (list): Callbacks will be executed after all transitions callbacks have been executed.
Callbacks mentioned here will also be called if a transition or condition check raised an error.
queued (bool): Whether transitions in callbacks should be executed immediately (False) or sequentially.
send_event (bool): When True, any arguments passed to trigger methods will be wrapped in an EventData
object, allowing indirect and encapsulated access to data. When False, all positional and keyword
arguments will be passed directly to all callback methods.
auto_transitions (bool): When True (default), every state will automatically have an associated
to_{state}() convenience trigger in the base model.
ignore_invalid_triggers (bool): When True, any calls to trigger methods that are not valid for the
present state (e.g., calling an a_to_b() trigger when the current state is c) will be silently
ignored rather than raising an invalid transition exception.
name (str): Name of the ``Machine`` instance mainly used for easier log message distinction.
"""
separator = '_' # separates callback type from state/transition name
wildcard_all = '*' # will be expanded to ALL states
wildcard_same = '=' # will be expanded to source state
state_cls = State
transition_cls = Transition
event_cls = Event
self_literal = 'self'
def __init__(self, model=self_literal, states=None, initial='initial', transitions=None,
send_event=False, auto_transitions=True,
ordered_transitions=False, ignore_invalid_triggers=None,
before_state_change=None, after_state_change=None, name=None,
queued=False, prepare_event=None, finalize_event=None, model_attribute='state', on_exception=None,
**kwargs):
"""
Args:
model (object or list): The object(s) whose states we want to manage. If set to `Machine.self_literal`
(default value), the current Machine instance will be used as the model (i.e., all
triggering events will be attached to the Machine itself). Note that an empty list
is treated like no model.
states (list or Enum): A list or enumeration of valid states. Each list element can be either a
string, an enum member or a State instance. If string or enum member, a new generic State
instance will be created that is named according to the string or enum member's name.
initial (str, Enum or State): The initial state of the passed model[s].
transitions (list): An optional list of transitions. Each element
is a dictionary of named arguments to be passed onto the
Transition initializer.
send_event (boolean): When True, any arguments passed to trigger
methods will be wrapped in an EventData object, allowing
indirect and encapsulated access to data. When False, all
positional and keyword arguments will be passed directly to all
callback methods.
auto_transitions (boolean): When True (default), every state will
automatically have an associated to_{state}() convenience
trigger in the base model.
ordered_transitions (boolean): Convenience argument that calls
add_ordered_transitions() at the end of initialization if set
to True.
ignore_invalid_triggers: when True, any calls to trigger methods
that are not valid for the present state (e.g., calling an
a_to_b() trigger when the current state is c) will be silently
ignored rather than raising an invalid transition exception.
before_state_change: A callable called on every change state before
the transition happened. It receives the very same args as normal
callbacks.
after_state_change: A callable called on every change state after
the transition happened. It receives the very same args as normal
callbacks.
name: If a name is set, it will be used as a prefix for logger output
queued (boolean): When True, processes transitions sequentially. A trigger
executed in a state callback function will be queued and executed later.
Due to the nature of the queued processing, all transitions will
_always_ return True since conditional checks cannot be conducted at queueing time.
prepare_event: A callable called on for before possible transitions will be processed.
It receives the very same args as normal callbacks.
finalize_event: A callable called on for each triggered event after transitions have been processed.
This is also called when a transition raises an exception.
on_exception: A callable called when an event raises an exception. If not set,
the exception will be raised instead.
**kwargs additional arguments passed to next class in MRO. This can be ignored in most cases.
"""
# calling super in case `Machine` is used as a mix in
# all keyword arguments should be consumed by now if this is not the case
try:
super(Machine, self).__init__(**kwargs)
except TypeError as err:
raise ValueError('Passing arguments {0} caused an inheritance error: {1}'.format(kwargs.keys(), err))
# initialize protected attributes first
self._queued = queued
self._transition_queue = deque()
self._before_state_change = []
self._after_state_change = []
self._prepare_event = []
self._finalize_event = []
self._on_exception = []
self._initial = None
self.states = OrderedDict()
self.events = {}
self.send_event = send_event
self.auto_transitions = auto_transitions
self.ignore_invalid_triggers = ignore_invalid_triggers
self.prepare_event = prepare_event
self.before_state_change = before_state_change
self.after_state_change = after_state_change
self.finalize_event = finalize_event
self.on_exception = on_exception
self.name = name + ": " if name is not None else ""
self.model_attribute = model_attribute
self.models = []
if states is not None:
self.add_states(states)
if initial is not None:
self.initial = initial
if transitions is not None:
self.add_transitions(transitions)
if ordered_transitions:
self.add_ordered_transitions()
if model:
self.add_model(model)
def add_model(self, model, initial=None):
""" Register a model with the state machine, initializing triggers and callbacks. """
models = listify(model)
if initial is None:
if self.initial is None:
raise ValueError("No initial state configured for machine, must specify when adding model.")
else:
initial = self.initial
for mod in models:
mod = self if mod is self.self_literal else mod
if mod not in self.models:
self._checked_assignment(mod, 'trigger', partial(self._get_trigger, mod))
for trigger in self.events:
self._add_trigger_to_model(trigger, mod)
for state in self.states.values():
self._add_model_to_state(state, mod)
self.set_state(initial, model=mod)
self.models.append(mod)
def remove_model(self, model):
""" Remove a model from the state machine. The model will still contain all previously added triggers
and callbacks, but will not receive updates when states or transitions are added to the Machine.
If an event queue is used, all queued events of that model will be removed."""
models = listify(model)
for mod in models:
self.models.remove(mod)
if len(self._transition_queue) > 0:
# the first element of the list is currently executed. Keeping it for further Machine._process(ing)
self._transition_queue = deque(
[self._transition_queue[0]] + [e for e in self._transition_queue if e.args[0] not in models])
@classmethod
def _create_transition(cls, *args, **kwargs):
return cls.transition_cls(*args, **kwargs)
@classmethod
def _create_event(cls, *args, **kwargs):
return cls.event_cls(*args, **kwargs)
@classmethod
def _create_state(cls, *args, **kwargs):
return cls.state_cls(*args, **kwargs)
@property
def initial(self):
""" Return the initial state. """
return self._initial
@initial.setter
def initial(self, value):
if isinstance(value, State):
if value.name not in self.states:
self.add_state(value)
else:
_ = self._has_state(value, raise_error=True)
self._initial = value.name
else:
state_name = value.name if isinstance(value, Enum) else value
if state_name not in self.states:
self.add_state(state_name)
self._initial = state_name
@property
def has_queue(self):
""" Return boolean indicating if machine has queue or not """
return self._queued
@property
def model(self):
""" List of models attached to the machine. For backwards compatibility, the property will
return the model instance itself instead of the underlying list if there is only one attached
to the machine.
"""
if len(self.models) == 1:
return self.models[0]
return self.models
@property
def before_state_change(self):
"""Callbacks executed after condition checks but before transition is conducted.
Callbacks will be executed BEFORE the custom callbacks assigned to the transition."""
return self._before_state_change
# this should make sure that _before_state_change is always a list
@before_state_change.setter
def before_state_change(self, value):
self._before_state_change = listify(value)
@property
def after_state_change(self):
"""Callbacks executed after the transition has been conducted.
Callbacks will be executed AFTER the custom callbacks assigned to the transition."""
return self._after_state_change
# this should make sure that _after_state_change is always a list
@after_state_change.setter
def after_state_change(self, value):
self._after_state_change = listify(value)
@property
def prepare_event(self):
"""Callbacks executed when an event is triggered."""
return self._prepare_event
# this should make sure that prepare_event is always a list
@prepare_event.setter
def prepare_event(self, value):
self._prepare_event = listify(value)
@property
def finalize_event(self):
"""Callbacks will be executed after all transitions callbacks have been executed.
Callbacks mentioned here will also be called if a transition or condition check raised an error."""
return self._finalize_event
# this should make sure that finalize_event is always a list
@finalize_event.setter
def finalize_event(self, value):
self._finalize_event = listify(value)
@property
def on_exception(self):
"""Callbacks will be executed when an Event raises an Exception."""
return self._on_exception
# this should make sure that finalize_event is always a list
@on_exception.setter
def on_exception(self, value):
self._on_exception = listify(value)
def get_state(self, state):
""" Return the State instance with the passed name. """
if isinstance(state, Enum):
state = state.name
if state not in self.states:
raise ValueError("State '%s' is not a registered state." % state)
return self.states[state]
# In theory this function could be static. This however causes some issues related to inheritance and
# pickling down the chain.
def is_state(self, state, model):
""" Check whether the current state matches the named state. This function is not called directly
but assigned as partials to model instances (e.g. is_A -> partial(_is_state, 'A', model)).
Args:
state (str): name of the checked state
model: model to be checked
Returns:
bool: Whether the model's current state is state.
"""
return getattr(model, self.model_attribute) == state
def get_model_state(self, model):
return self.get_state(getattr(model, self.model_attribute))
def set_state(self, state, model=None):
"""
Set the current state.
Args:
state (str or Enum or State): value of state to be set
model (optional[object]): targeted model; if not set, all models will be set to 'state'
"""
if not isinstance(state, State):
state = self.get_state(state)
models = self.models if model is None else listify(model)
for mod in models:
setattr(mod, self.model_attribute, state.value)
def add_state(self, *args, **kwargs):
""" Alias for add_states. """
self.add_states(*args, **kwargs)
def add_states(self, states, on_enter=None, on_exit=None,
ignore_invalid_triggers=None, **kwargs):
""" Add new state(s).
Args:
states (list, str, dict, Enum or State): a list, a State instance, the
name of a new state, an enumeration (member) or a dict with keywords to pass on to the
State initializer. If a list, each element can be a string, State or enumeration member.
on_enter (str or list): callbacks to trigger when the state is
entered. Only valid if first argument is string.
on_exit (str or list): callbacks to trigger when the state is
exited. Only valid if first argument is string.
ignore_invalid_triggers: when True, any calls to trigger methods
that are not valid for the present state (e.g., calling an
a_to_b() trigger when the current state is c) will be silently
ignored rather than raising an invalid transition exception.
Note that this argument takes precedence over the same
argument defined at the Machine level, and is in turn
overridden by any ignore_invalid_triggers explicitly
passed in an individual state's initialization arguments.
**kwargs additional keyword arguments used by state mixins.
"""
ignore = ignore_invalid_triggers
if ignore is None:
ignore = self.ignore_invalid_triggers
states = listify(states)
for state in states:
if isinstance(state, (string_types, Enum)):
state = self._create_state(
state, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore, **kwargs)
elif isinstance(state, dict):
if 'ignore_invalid_triggers' not in state:
state['ignore_invalid_triggers'] = ignore
state = self._create_state(**state)
self.states[state.name] = state
for model in self.models:
self._add_model_to_state(state, model)
if self.auto_transitions:
for a_state in self.states.keys():
# add all states as sources to auto transitions 'to_' with dest
if a_state == state.name:
if self.model_attribute == 'state':
method_name = 'to_%s' % a_state
else:
method_name = 'to_%s_%s' % (self.model_attribute, a_state)
self.add_transition('to_%s' % a_state, self.wildcard_all, a_state,
prepare=partial(_warning_wrapper_to, 'to_%s' % a_state))
self.add_transition(method_name, self.wildcard_all, a_state)
# add auto transition with source to
else:
if self.model_attribute == 'state':
method_name = 'to_%s' % a_state
else:
method_name = 'to_%s_%s' % (self.model_attribute, a_state)
self.add_transition('to_%s' % a_state, state.name, a_state,
prepare=partial(_warning_wrapper_to, 'to_%s' % a_state))
self.add_transition(method_name, state.name, a_state)
def _add_model_to_state(self, state, model):
# Add convenience function 'is_' (e.g. 'is_A') to the model.
# When model_attribute has been customized, add 'is__' instead
# to potentially support multiple states on one model (e.g. 'is_custom_state_A' and 'is_my_state_B').
func = partial(self.is_state, state.value, model)
if self.model_attribute == 'state':
method_name = 'is_%s' % state.name
else:
method_name = 'is_%s_%s' % (self.model_attribute, state.name)
self._checked_assignment(model, 'is_%s' % state.name, partial(_warning_wrapper_is, method_name, func))
self._checked_assignment(model, method_name, func)
# Add dynamic method callbacks (enter/exit) if there are existing bound methods in the model
# except if they are already mentioned in 'on_enter/exit' of the defined state
for callback in self.state_cls.dynamic_methods:
method = "{0}_{1}".format(callback, state.name)
if hasattr(model, method) and inspect.ismethod(getattr(model, method)) and \
method not in getattr(state, callback):
state.add_callback(callback[3:], method)
def _checked_assignment(self, model, name, func):
if hasattr(model, name):
_LOGGER.warning("%sModel already contains an attribute '%s'. Skip binding.", self.name, name)
else:
setattr(model, name, func)
def _add_trigger_to_model(self, trigger, model):
self._checked_assignment(model, trigger, partial(self.events[trigger].trigger, model))
def _get_trigger(self, model, trigger_name, *args, **kwargs):
"""Convenience function added to the model to trigger events by name.
Args:
model (object): Model with assigned event trigger.
trigger_name (str): Name of the trigger to be called.
*args: Variable length argument list which is passed to the triggered event.
**kwargs: Arbitrary keyword arguments which is passed to the triggered event.
Returns:
bool: True if a transitions has been conducted or the trigger event has been queued.
"""
try:
event = self.events[trigger_name]
except KeyError:
state = self.get_model_state(model)
ignore = state.ignore_invalid_triggers if state.ignore_invalid_triggers is not None \
else self.ignore_invalid_triggers
if not ignore:
raise AttributeError("Do not know event named '%s'." % trigger_name)
return False
return event.trigger(model, *args, **kwargs)
def get_triggers(self, *args):
""" Collects all triggers FROM certain states.
Args:
*args: Tuple of source states.
Returns:
list of transition/trigger names.
"""
names = set([state.name if hasattr(state, 'name') else state for state in args])
return [t for (t, ev) in self.events.items() if any(name in ev.transitions for name in names)]
def add_transition(self, trigger, source, dest, conditions=None,
unless=None, before=None, after=None, prepare=None, **kwargs):
""" Create a new Transition instance and add it to the internal list.
Args:
trigger (str): The name of the method that will trigger the
transition. This will be attached to the currently specified
model (e.g., passing trigger='advance' will create a new
advance() method in the model that triggers the transition.)
source(str or list): The name of the source state--i.e., the state we
are transitioning away from. This can be a single state, a
list of states or an asterisk for all states.
dest (str): The name of the destination State--i.e., the state
we are transitioning into. This can be a single state or an
equal sign to specify that the transition should be reflexive
so that the destination will be the same as the source for
every given source. If dest is None, this transition will be
an internal transition (exit/enter callbacks won't be processed).
conditions (str or list): Condition(s) that must pass in order
for the transition to take place. Either a list providing the
name of a callable, or a list of callables. For the transition
to occur, ALL callables must return True.
unless (str or list): Condition(s) that must return False in order
for the transition to occur. Behaves just like conditions arg
otherwise.
before (str or list): Callables to call before the transition.
after (str or list): Callables to call after the transition.
prepare (str or list): Callables to call when the trigger is activated
**kwargs: Additional arguments which can be passed to the created transition.
This is useful if you plan to extend Machine.Transition and require more parameters.
"""
if trigger == self.model_attribute:
raise ValueError("Trigger name cannot be same as model attribute name.")
if trigger not in self.events:
self.events[trigger] = self._create_event(trigger, self)
for model in self.models:
self._add_trigger_to_model(trigger, model)
if source == self.wildcard_all:
source = list(self.states.keys())
else:
# states are checked lazily which means we will only raise exceptions when the passed state
# is a State object because of potential confusion (see issue #155 for more details)
source = [s.name if isinstance(s, State) and self._has_state(s, raise_error=True) or hasattr(s, 'name') else
s for s in listify(source)]
for state in source:
if dest == self.wildcard_same:
_dest = state
elif dest is not None:
if isinstance(dest, State):
_ = self._has_state(dest, raise_error=True)
_dest = dest.name if hasattr(dest, 'name') else dest
else:
_dest = None
_trans = self._create_transition(state, _dest, conditions, unless, before,
after, prepare, **kwargs)
self.events[trigger].add_transition(_trans)
def add_transitions(self, transitions):
""" Add several transitions.
Args:
transitions (list): A list of transitions.
"""
for trans in listify(transitions):
if isinstance(trans, list):
self.add_transition(*trans)
else:
self.add_transition(**trans)
def add_ordered_transitions(self, states=None, trigger='next_state',
loop=True, loop_includes_initial=True,
conditions=None, unless=None, before=None,
after=None, prepare=None, **kwargs):
""" Add a set of transitions that move linearly from state to state.
Args:
states (list): A list of state names defining the order of the
transitions. E.g., ['A', 'B', 'C'] will generate transitions
for A --> B, B --> C, and C --> A (if loop is True). If states
is None, all states in the current instance will be used.
trigger (str): The name of the trigger method that advances to
the next state in the sequence.
loop (boolean): Whether or not to add a transition from the last
state to the first state.
loop_includes_initial (boolean): If no initial state was defined in
the machine, setting this to True will cause the _initial state
placeholder to be included in the added transitions. This argument
has no effect if the states argument is passed without the
initial state included.
conditions (str or list): Condition(s) that must pass in order
for the transition to take place. Either a list providing the
name of a callable, or a list of callables. For the transition
to occur, ALL callables must return True.
unless (str or list): Condition(s) that must return False in order
for the transition to occur. Behaves just like conditions arg
otherwise.
before (str or list): Callables to call before the transition.
after (str or list): Callables to call after the transition.
prepare (str or list): Callables to call when the trigger is activated
**kwargs: Additional arguments which can be passed to the created transition.
This is useful if you plan to extend Machine.Transition and require more parameters.
"""
if states is None:
states = list(self.states.keys()) # need to listify for Python3
len_transitions = len(states)
if len_transitions < 2:
raise ValueError("Can't create ordered transitions on a Machine "
"with fewer than 2 states.")
if not loop:
len_transitions -= 1
# ensure all args are the proper length
conditions = _prep_ordered_arg(len_transitions, conditions)
unless = _prep_ordered_arg(len_transitions, unless)
before = _prep_ordered_arg(len_transitions, before)
after = _prep_ordered_arg(len_transitions, after)
prepare = _prep_ordered_arg(len_transitions, prepare)
# reorder list so that the initial state is actually the first one
try:
idx = states.index(self._initial)
states = states[idx:] + states[:idx]
first_in_loop = states[0 if loop_includes_initial else 1]
except ValueError:
# since initial is not part of states it shouldn't be part of the loop either
first_in_loop = states[0]
for i in range(0, len(states) - 1):
self.add_transition(trigger, states[i], states[i + 1],
conditions=conditions[i],
unless=unless[i],
before=before[i],
after=after[i],
prepare=prepare[i],
**kwargs)
if loop:
self.add_transition(trigger, states[-1],
# omit initial if not loop_includes_initial
first_in_loop,
conditions=conditions[-1],
unless=unless[-1],
before=before[-1],
after=after[-1],
prepare=prepare[-1],
**kwargs)
def get_transitions(self, trigger="", source="*", dest="*"):
""" Return the transitions from the Machine.
Args:
trigger (str): Trigger name of the transition.
source (str, Enum or State): Limits list to transitions from a certain state.
dest (str, Enum or State): Limits list to transitions to a certain state.
"""
if trigger:
try:
events = (self.events[trigger], )
except KeyError:
return []
else:
events = self.events.values()
transitions = []
for event in events:
transitions.extend(
itertools.chain.from_iterable(event.transitions.values()))
target_source = source.name if hasattr(source, 'name') else source if source != "*" else ""
target_dest = dest.name if hasattr(dest, 'name') else dest if dest != "*" else ""
return [transition
for transition in transitions
if (transition.source, transition.dest) == (target_source or transition.source,
target_dest or transition.dest)]
def remove_transition(self, trigger, source="*", dest="*"):
""" Removes a transition from the Machine and all models.
Args:
trigger (str): Trigger name of the transition.
source (str): Limits removal to transitions from a certain state.
dest (str): Limits removal to transitions to a certain state.
"""
source = listify(source) if source != "*" else source
dest = listify(dest) if dest != "*" else dest
# outer comprehension, keeps events if inner comprehension returns lists with length > 0
tmp = {key: value for key, value in
{k: [t for t in v
# keep entries if source should not be filtered; same for dest.
if (source != "*" and t.source not in source) or (dest != "*" and t.dest not in dest)]
# }.items() takes the result of the inner comprehension and uses it
# for the outer comprehension (see first line of comment)
for k, v in self.events[trigger].transitions.items()}.items()
if len(value) > 0}
# convert dict back to defaultdict in case tmp is not empty
if tmp:
self.events[trigger].transitions = defaultdict(list, **tmp)
# if no transition is left remove the trigger from the machine and all models
else:
for model in self.models:
delattr(model, trigger)
del self.events[trigger]
def dispatch(self, trigger, *args, **kwargs):
""" Trigger an event on all models assigned to the machine.
Args:
trigger (str): Event name
*args (list): List of arguments passed to the event trigger
**kwargs (dict): Dictionary of keyword arguments passed to the event trigger
Returns:
bool The truth value of all triggers combined with AND
"""
return all([getattr(model, trigger)(*args, **kwargs) for model in self.models])
def callbacks(self, funcs, event_data):
""" Triggers a list of callbacks """
for func in funcs:
self.callback(func, event_data)
_LOGGER.info("%sExecuted callback '%s'", self.name, func)
def callback(self, func, event_data):
""" Trigger a callback function with passed event_data parameters. In case func is a string,
the callable will be resolved from the passed model in event_data. This function is not intended to
be called directly but through state and transition callback definitions.
Args:
func (str or callable): The callback function.
1. First, if the func is callable, just call it
2. Second, we try to import string assuming it is a path to a func
3. Fallback to a model attribute
event_data (EventData): An EventData instance to pass to the
callback (if event sending is enabled) or to extract arguments
from (if event sending is disabled).
"""
func = self.resolve_callable(func, event_data)
if self.send_event:
func(event_data)
else:
func(*event_data.args, **event_data.kwargs)
@staticmethod
def resolve_callable(func, event_data):
""" Converts a model's property name, method name or a path to a callable into a callable.
If func is not a string it will be returned unaltered.
Args:
func (str or callable): Property name, method name or a path to a callable
event_data (EventData): Currently processed event
Returns:
callable function resolved from string or func
"""
if isinstance(func, string_types):
try:
func = getattr(event_data.model, func)
if not callable(func): # if a property or some other not callable attribute was passed
def func_wrapper(*_, **__): # properties cannot process parameters
return func
return func_wrapper
except AttributeError:
try:
mod, name = func.rsplit('.', 1)
m = __import__(mod)
for n in mod.split('.')[1:]:
m = getattr(m, n)
func = getattr(m, name)
except (ImportError, AttributeError, ValueError):
raise AttributeError("Callable with name '%s' could neither be retrieved from the passed "
"model nor imported from a module." % func)
return func
def _has_state(self, state, raise_error=False):
found = state in self.states.values()
if not found and raise_error:
msg = 'State %s has not been added to the machine' % (state.name if hasattr(state, 'name') else state)
raise ValueError(msg)
return found
def _process(self, trigger):
# default processing
if not self.has_queue:
if not self._transition_queue:
# if trigger raises an Error, it has to be handled by the Machine.process caller
return trigger()
else:
raise MachineError("Attempt to process events synchronously while transition queue is not empty!")
# process queued events
self._transition_queue.append(trigger)
# another entry in the queue implies a running transition; skip immediate execution
if len(self._transition_queue) > 1:
return True
# execute as long as transition queue is not empty
while self._transition_queue:
try:
self._transition_queue[0]()
self._transition_queue.popleft()
except Exception:
# if a transition raises an exception, clear queue and delegate exception handling
self._transition_queue.clear()
raise
return True
@classmethod
def _identify_callback(cls, name):
# Does the prefix match a known callback?
for callback in itertools.chain(cls.state_cls.dynamic_methods, cls.transition_cls.dynamic_methods):
if name.startswith(callback):
callback_type = callback
break
else:
return None, None
# Extract the target by cutting the string after the type and separator
target = name[len(callback_type) + len(cls.separator):]
# Make sure there is actually a target to avoid index error and enforce _ as a separator
if target == '' or name[len(callback_type)] != cls.separator:
return None, None
return callback_type, target
def __getattr__(self, name):
# Machine.__dict__ does not contain double underscore variables.
# Class variables will be mangled.
if name.startswith('__'):
raise AttributeError("'{}' does not exist on "
.format(name, id(self)))
# Could be a callback
callback_type, target = self._identify_callback(name)
if callback_type is not None:
if callback_type in self.transition_cls.dynamic_methods:
if target not in self.events:
raise AttributeError("event '{}' is not registered on "
.format(target, id(self)))
return partial(self.events[target].add_callback, callback_type)
elif callback_type in self.state_cls.dynamic_methods:
state = self.get_state(target)
return partial(state.add_callback, callback_type[3:])
try:
return self.__getattribute__(name)
except AttributeError:
# Nothing matched
raise AttributeError("'{}' does not exist on ".format(name, id(self)))
class MachineError(Exception):
""" MachineError is used for issues related to state transitions and current states.
For instance, it is raised for invalid transitions or machine configuration issues.
"""
def __init__(self, value):
super(MachineError, self).__init__(value)
self.value = value
def __str__(self):
return repr(self.value)
# TODO: Remove in 0.9.0
def _warning_wrapper_is(meth_name, func, *args, **kwargs):
warnings.warn("Starting from transitions version 0.8.3, 'is_' convenience functions will be"
" assigned to 'is__' when 'model_attribute "
"!= \"state\"'. In 0.9.0, 'is_' will NOT be assigned anymore when "
"'model_attribute != \"state\"'! Please adjust your code and use "
"'{0}' instead.".format(meth_name), DeprecationWarning)
return func(*args, **kwargs)
def _warning_wrapper_to(meth_name, *args, **kwargs):
warnings.warn("Starting from transitions version 0.8.3, 'to_' convenience functions will be"
" assigned to 'to__' when 'model_attribute "
"!= \"state\"'. In 0.9.0, 'to_' will NOT be assigned anymore when "
"'model_attribute != \"state\"'! Please adjust your code and use "
"'{0}' instead.".format(meth_name), DeprecationWarning)
transitions-0.8.10+3/transitions/extensions/ 0000755 0002322 0002322 00000000000 14155650047 021444 5 ustar debalance debalance transitions-0.8.10+3/transitions/extensions/diagrams.py 0000644 0002322 0002322 00000032545 14155650047 023616 0 ustar debalance debalance from transitions import Transition
from transitions.extensions.markup import MarkupMachine
from transitions.core import listify
import logging
from functools import partial
import copy
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# this is a workaround for dill issues when partials and super is used in conjunction
# without it, Python 3.0 - 3.3 will not support pickling
# https://github.com/pytransitions/transitions/issues/236
_super = super
class TransitionGraphSupport(Transition):
""" Transition used in conjunction with (Nested)Graphs to update graphs whenever a transition is
conducted.
"""
def __init__(self, *args, **kwargs):
label = kwargs.pop('label', None)
_super(TransitionGraphSupport, self).__init__(*args, **kwargs)
if label:
self.label = label
def _change_state(self, event_data):
graph = event_data.machine.model_graphs[id(event_data.model)]
graph.reset_styling()
graph.set_previous_transition(self.source, self.dest, event_data.event.name)
_super(TransitionGraphSupport, self)._change_state(event_data) # pylint: disable=protected-access
graph = event_data.machine.model_graphs[id(event_data.model)] # graph might have changed during change_event
for state in _flatten(listify(getattr(event_data.model, event_data.machine.model_attribute))):
graph.set_node_style(self.dest if hasattr(state, 'name') else state, 'active')
class GraphMachine(MarkupMachine):
""" Extends transitions.core.Machine with graph support.
Is also used as a mixin for HierarchicalMachine.
Attributes:
_pickle_blacklist (list): Objects that should not/do not need to be pickled.
transition_cls (cls): TransitionGraphSupport
"""
_pickle_blacklist = ['model_graphs']
transition_cls = TransitionGraphSupport
machine_attributes = {
'directed': 'true',
'strict': 'false',
'rankdir': 'LR',
}
hierarchical_machine_attributes = {
'rankdir': 'TB',
'rank': 'source',
'nodesep': '1.5',
'compound': 'true'
}
style_attributes = {
'node': {
'': {},
'default': {
'style': 'rounded, filled',
'shape': 'rectangle',
'fillcolor': 'white',
'color': 'black',
'peripheries': '1'
},
'inactive': {
'fillcolor': 'white',
'color': 'black',
'peripheries': '1'
},
'parallel': {
'shape': 'rectangle',
'color': 'black',
'fillcolor': 'white',
'style': 'dashed, rounded, filled',
'peripheries': '1'
},
'active': {
'color': 'red',
'fillcolor': 'darksalmon',
'peripheries': '2'
},
'previous': {
'color': 'blue',
'fillcolor': 'azure2',
'peripheries': '1'
}
},
'edge': {
'': {},
'default': {
'color': 'black'
},
'previous': {
'color': 'blue'
}
},
'graph': {
'': {},
'default': {
'color': 'black',
'fillcolor': 'white',
'style': 'solid'
},
'previous': {
'color': 'blue',
'fillcolor': 'azure2',
'style': 'filled'
},
'active': {
'color': 'red',
'fillcolor': 'darksalmon',
'style': 'filled'
},
'parallel': {
'color': 'black',
'fillcolor': 'white',
'style': 'dotted'
}
}
}
# model_graphs cannot be pickled. Omit them.
def __getstate__(self):
# self.pkl_graphs = [(g.markup, g.custom_styles) for g in self.model_graphs]
return {k: v for k, v in self.__dict__.items() if k not in self._pickle_blacklist}
def __setstate__(self, state):
self.__dict__.update(state)
self.model_graphs = {} # reinitialize new model_graphs
for model in self.models:
try:
_ = self._get_graph(model, title=self.title)
except AttributeError as e:
_LOGGER.warning("Graph for model could not be initialized after pickling: %s", e)
def __init__(self, *args, **kwargs):
# remove graph config from keywords
self.title = kwargs.pop('title', 'State Machine')
self.show_conditions = kwargs.pop('show_conditions', False)
self.show_state_attributes = kwargs.pop('show_state_attributes', False)
# in MarkupMachine this switch is called 'with_auto_transitions'
# keep 'auto_transitions_markup' for backwards compatibility
kwargs['auto_transitions_markup'] = kwargs.get('auto_transitions_markup', False) or \
kwargs.pop('show_auto_transitions', False)
self.model_graphs = {}
# determine graph engine; if pygraphviz cannot be imported, fall back to graphviz
use_pygraphviz = kwargs.pop('use_pygraphviz', True)
if use_pygraphviz:
try:
import pygraphviz
except ImportError:
use_pygraphviz = False
self.graph_cls = self._init_graphviz_engine(use_pygraphviz)
_LOGGER.debug("Using graph engine %s", self.graph_cls)
_super(GraphMachine, self).__init__(*args, **kwargs)
# for backwards compatibility assign get_combined_graph to get_graph
# if model is not the machine
if not hasattr(self, 'get_graph'):
setattr(self, 'get_graph', self.get_combined_graph)
def _init_graphviz_engine(self, use_pygraphviz):
if use_pygraphviz:
try:
# state class needs to have a separator and machine needs to be a context manager
if hasattr(self.state_cls, 'separator') and hasattr(self, '__enter__'):
from .diagrams_pygraphviz import NestedGraph as Graph
self.machine_attributes.update(self.hierarchical_machine_attributes)
else:
from .diagrams_pygraphviz import Graph
return Graph
except ImportError:
pass
if hasattr(self.state_cls, 'separator') and hasattr(self, '__enter__'):
from .diagrams_graphviz import NestedGraph as Graph
self.machine_attributes.update(self.hierarchical_machine_attributes)
else:
from .diagrams_graphviz import Graph
return Graph
def _get_graph(self, model, title=None, force_new=False, show_roi=False):
if force_new:
grph = self.graph_cls(self, title=title if title is not None else self.title)
self.model_graphs[id(model)] = grph
try:
for state in _flatten(listify(getattr(model, self.model_attribute))):
grph.set_node_style(self.dest if hasattr(state, 'name') else state, 'active')
except AttributeError:
_LOGGER.info("Could not set active state of diagram")
try:
m = self.model_graphs[id(model)]
except KeyError:
_ = self._get_graph(model, title, force_new=True)
m = self.model_graphs[id(model)]
m.roi_state = getattr(model, self.model_attribute) if show_roi else None
return m.get_graph(title=title)
def get_combined_graph(self, title=None, force_new=False, show_roi=False):
""" This method is currently equivalent to 'get_graph' of the first machine's model.
In future releases of transitions, this function will return a combined graph with active states
of all models.
Args:
title (str): Title of the resulting graph.
force_new (bool): If set to True, (re-)generate the model's graph.
show_roi (bool): If set to True, only render states that are active and/or can be reached from
the current state.
Returns: AGraph of the first machine's model.
"""
_LOGGER.info('Returning graph of the first model. In future releases, this '
'method will return a combined graph of all models.')
return self._get_graph(self.models[0], title, force_new, show_roi)
def add_model(self, model, initial=None):
models = listify(model)
super(GraphMachine, self).add_model(models, initial)
for mod in models:
mod = self if mod is self.self_literal else mod
if hasattr(mod, 'get_graph'):
raise AttributeError('Model already has a get_graph attribute. Graph retrieval cannot be bound.')
setattr(mod, 'get_graph', partial(self._get_graph, mod))
_ = mod.get_graph(title=self.title, force_new=True) # initialises graph
def add_states(self, states, on_enter=None, on_exit=None,
ignore_invalid_triggers=None, **kwargs):
""" Calls the base method and regenerates all models's graphs. """
_super(GraphMachine, self).add_states(states, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers, **kwargs)
for model in self.models:
model.get_graph(force_new=True)
def add_transition(self, trigger, source, dest, conditions=None,
unless=None, before=None, after=None, prepare=None, **kwargs):
""" Calls the base method and regenerates all models's graphs. """
_super(GraphMachine, self).add_transition(trigger, source, dest, conditions=conditions, unless=unless,
before=before, after=after, prepare=prepare, **kwargs)
for model in self.models:
model.get_graph(force_new=True)
class BaseGraph(object):
def __init__(self, machine, title=None):
self.machine = machine
self.fsm_graph = None
self.roi_state = None
self.generate(title)
def _convert_state_attributes(self, state):
label = state.get('label', state['name'])
if self.machine.show_state_attributes:
if 'tags' in state:
label += ' [' + ', '.join(state['tags']) + ']'
if 'on_enter' in state:
label += r'\l- enter:\l + ' + r'\l + '.join(state['on_enter'])
if 'on_exit' in state:
label += r'\l- exit:\l + ' + r'\l + '.join(state['on_exit'])
if 'timeout' in state:
label += r'\l- timeout(' + state['timeout'] + 's) -> (' + ', '.join(state['on_timeout']) + ')'
return label
def _transition_label(self, tran):
edge_label = tran.get('label', tran['trigger'])
if 'dest' not in tran:
edge_label += " [internal]"
if self.machine.show_conditions and any(prop in tran for prop in ['conditions', 'unless']):
x = '{edge_label} [{conditions}]'.format(
edge_label=edge_label,
conditions=' & '.join(tran.get('conditions', []) + ['!' + u for u in tran.get('unless', [])]),
)
return x
return edge_label
def _get_global_name(self, path):
if path:
state = path.pop(0)
with self.machine(state):
return self._get_global_name(path)
else:
return self.machine.get_global_name()
def _get_elements(self):
states = []
transitions = []
try:
markup = self.machine.get_markup_config()
q = [([], markup)]
while q:
prefix, scope = q.pop(0)
for transition in scope.get('transitions', []):
if prefix:
t = copy.copy(transition)
t['source'] = self.machine.state_cls.separator.join(prefix + [t['source']])
if 'dest' in t: # don't do this for internal transitions
t['dest'] = self.machine.state_cls.separator.join(prefix + [t['dest']])
else:
t = transition
transitions.append(t)
for state in scope.get('children', []) + scope.get('states', []):
if not prefix:
s = state
states.append(s)
ini = state.get('initial', [])
if not isinstance(ini, list):
ini = ini.name if hasattr(ini, 'name') else ini
t = dict(trigger='',
source=self.machine.state_cls.separator.join(prefix + [state['name']]) + '_anchor',
dest=self.machine.state_cls.separator.join(prefix + [state['name'], ini]))
transitions.append(t)
if state.get('children', []):
q.append((prefix + [state['name']], state))
except KeyError as e:
_LOGGER.error("Graph creation incomplete!")
return states, transitions
def _flatten(item):
for elem in item:
if isinstance(elem, (list, tuple, set)):
for res in _flatten(elem):
yield res
else:
yield elem
transitions-0.8.10+3/transitions/extensions/factory.py 0000644 0002322 0002322 00000010375 14155650047 023473 0 ustar debalance debalance """
transitions.extensions.factory
------------------------------
This module contains the definitions of classes which combine the functionality of transitions'
extension modules. These classes can be accessed by names as well as through a static convenience
factory object.
"""
from functools import partial
from ..core import Machine
from .nesting import HierarchicalMachine, NestedTransition, NestedEvent
from .locking import LockedMachine
from .diagrams import GraphMachine, TransitionGraphSupport
from .markup import MarkupMachine
try:
from transitions.extensions.asyncio import AsyncMachine, AsyncTransition
from transitions.extensions.asyncio import HierarchicalAsyncMachine, NestedAsyncTransition
except (ImportError, SyntaxError):
class AsyncMachine: # Mocks for Python version 3.6 and earlier
pass
class AsyncTransition:
pass
class HierarchicalAsyncMachine:
pass
class NestedAsyncTransition:
pass
class MachineFactory(object):
"""
Convenience factory for machine class retrieval.
"""
# get one of the predefined classes which fulfill the criteria
@staticmethod
def get_predefined(graph=False, nested=False, locked=False, asyncio=False):
""" A function to retrieve machine classes by required functionality.
Args:
graph (bool): Whether the returned class should contain graph support.
nested: Whether the returned machine class should support nested states.
locked: Whether the returned class should facilitate locks for threadsafety.
Returns (class): A machine class with the specified features.
"""
try:
return _CLASS_MAP[(graph, nested, locked, asyncio)]
except KeyError:
raise ValueError("Feature combination not (yet) supported")
class NestedGraphTransition(TransitionGraphSupport, NestedTransition):
"""
A transition type to be used with (subclasses of) `HierarchicalGraphMachine` and
`LockedHierarchicalGraphMachine`.
"""
pass
class HierarchicalMarkupMachine(MarkupMachine, HierarchicalMachine):
pass
class HierarchicalGraphMachine(GraphMachine, HierarchicalMarkupMachine):
"""
A hierarchical state machine with graph support.
"""
transition_cls = NestedGraphTransition
class LockedHierarchicalMachine(LockedMachine, HierarchicalMachine):
"""
A threadsafe hierarchical machine.
"""
event_cls = NestedEvent
def _get_qualified_state_name(self, state):
return self.get_global_name(state.name)
class LockedGraphMachine(GraphMachine, LockedMachine):
"""
A threadsafe machine with graph support.
"""
@staticmethod
def format_references(func):
if isinstance(func, partial) and func.func.__name__.startswith('_locked_method'):
func = func.args[0]
return GraphMachine.format_references(func)
class LockedHierarchicalGraphMachine(GraphMachine, LockedHierarchicalMachine):
"""
A threadsafe hierarchical machine with graph support.
"""
transition_cls = NestedGraphTransition
event_cls = NestedEvent
@staticmethod
def format_references(func):
if isinstance(func, partial) and func.func.__name__.startswith('_locked_method'):
func = func.args[0]
return GraphMachine.format_references(func)
class AsyncGraphMachine(GraphMachine, AsyncMachine):
transition_cls = AsyncTransition
class HierarchicalAsyncGraphMachine(GraphMachine, HierarchicalAsyncMachine):
transition_cls = NestedAsyncTransition
# 4d tuple (graph, nested, locked, async)
_CLASS_MAP = {
(False, False, False, False): Machine,
(False, False, True, False): LockedMachine,
(False, True, False, False): HierarchicalMachine,
(False, True, True, False): LockedHierarchicalMachine,
(True, False, False, False): GraphMachine,
(True, False, True, False): LockedGraphMachine,
(True, True, False, False): HierarchicalGraphMachine,
(True, True, True, False): LockedHierarchicalGraphMachine,
(False, False, False, True): AsyncMachine,
(True, False, False, True): AsyncGraphMachine,
(False, True, False, True): HierarchicalAsyncMachine,
(True, True, False, True): HierarchicalAsyncGraphMachine
}
transitions-0.8.10+3/transitions/extensions/__init__.py 0000644 0002322 0002322 00000001300 14155650047 023547 0 ustar debalance debalance """
transitions.extensions
----------------------
Additional functionality such as hierarchical (nested) machine support, Graphviz-based diagram creation
and threadsafe execution of machine methods. Additionally, combinations of all those features are possible
and made easier to access with a convenience factory.
"""
from .diagrams import GraphMachine
from .nesting import HierarchicalMachine
from .locking import LockedMachine
from .factory import MachineFactory, HierarchicalGraphMachine, LockedHierarchicalGraphMachine
from .factory import LockedHierarchicalMachine, LockedGraphMachine
from .factory import AsyncMachine, AsyncGraphMachine, HierarchicalAsyncMachine, HierarchicalAsyncGraphMachine
transitions-0.8.10+3/transitions/extensions/diagrams_pygraphviz.py 0000644 0002322 0002322 00000024505 14155650047 026076 0 ustar debalance debalance """
transitions.extensions.diagrams
-------------------------------
Graphviz support for (nested) machines. This also includes partial views
of currently valid transitions.
"""
import logging
import copy
from .nesting import NestedState
from .diagrams import BaseGraph
try:
import pygraphviz as pgv
except ImportError: # pragma: no cover
pgv = None
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# this is a workaround for dill issues when partials and super is used in conjunction
# without it, Python 3.0 - 3.3 will not support pickling
# https://github.com/pytransitions/transitions/issues/236
_super = super
class Graph(BaseGraph):
""" Graph creation for transitions.core.Machine.
Attributes:
machine (object): Reference to the related machine.
"""
def _add_nodes(self, states, container):
for state in states:
shape = self.machine.style_attributes['node']['default']['shape']
container.add_node(state['name'], label=self._convert_state_attributes(state), shape=shape)
def _add_edges(self, transitions, container):
for transition in transitions:
src = transition['source']
edge_attr = {'label': self._transition_label(transition)}
try:
dst = transition['dest']
except KeyError:
dst = src
if container.has_edge(src, dst):
edge = container.get_edge(src, dst)
edge.attr['label'] = edge.attr['label'] + ' | ' + edge_attr['label']
else:
container.add_edge(src, dst, **edge_attr)
def generate(self, title=None):
""" Generate a DOT graph with pygraphviz, returns an AGraph object """
if not pgv: # pragma: no cover
raise Exception('AGraph diagram requires pygraphviz')
title = '' if not title else title
self.fsm_graph = pgv.AGraph(label=title, **self.machine.machine_attributes)
self.fsm_graph.node_attr.update(self.machine.style_attributes['node']['default'])
self.fsm_graph.edge_attr.update(self.machine.style_attributes['edge']['default'])
states, transitions = self._get_elements()
self._add_nodes(states, self.fsm_graph)
self._add_edges(transitions, self.fsm_graph)
setattr(self.fsm_graph, 'style_attributes', self.machine.style_attributes)
return self.fsm_graph
def get_graph(self, title=None):
if title:
self.fsm_graph.graph_attr['label'] = title
if self.roi_state:
filtered = _copy_agraph(self.fsm_graph)
kept_nodes = set()
active_state = self.roi_state.name if hasattr(self.roi_state, 'name') else self.roi_state
if not filtered.has_node(self.roi_state):
active_state += '_anchor'
kept_nodes.add(active_state)
# remove all edges that have no connection to the currently active state
for edge in filtered.edges():
if active_state not in edge:
filtered.delete_edge(edge)
# find the ingoing edge by color; remove the rest
for edge in filtered.in_edges(active_state):
if edge.attr['color'] == self.fsm_graph.style_attributes['edge']['previous']['color']:
kept_nodes.add(edge[0])
else:
filtered.delete_edge(edge)
# remove outgoing edges from children
for edge in filtered.out_edges_iter(active_state):
kept_nodes.add(edge[1])
for node in filtered.nodes():
if node not in kept_nodes:
filtered.delete_node(node)
return filtered
else:
return self.fsm_graph
def set_node_style(self, state, style):
node = self.fsm_graph.get_node(state)
style_attr = self.fsm_graph.style_attributes.get('node', {}).get(style)
node.attr.update(style_attr)
def set_previous_transition(self, src, dst, key=None):
try:
edge = self.fsm_graph.get_edge(src, dst)
except KeyError:
self.fsm_graph.add_edge(src, dst)
edge = self.fsm_graph.get_edge(src, dst)
style_attr = self.fsm_graph.style_attributes.get('edge', {}).get('previous')
edge.attr.update(style_attr)
self.set_node_style(src, 'previous')
self.set_node_style(dst, 'active')
def reset_styling(self):
for edge in self.fsm_graph.edges_iter():
style_attr = self.fsm_graph.style_attributes.get('edge', {}).get('default')
edge.attr.update(style_attr)
for node in self.fsm_graph.nodes_iter():
if 'point' not in node.attr['shape']:
style_attr = self.fsm_graph.style_attributes.get('node', {}).get('inactive')
node.attr.update(style_attr)
for sub_graph in self.fsm_graph.subgraphs_iter():
style_attr = self.fsm_graph.style_attributes.get('graph', {}).get('default')
sub_graph.graph_attr.update(style_attr)
class NestedGraph(Graph):
""" Graph creation support for transitions.extensions.nested.HierarchicalGraphMachine. """
def __init__(self, *args, **kwargs):
self.seen_transitions = []
_super(NestedGraph, self).__init__(*args, **kwargs)
def _add_nodes(self, states, container, prefix='', default_style='default'):
for state in states:
name = prefix + state['name']
label = self._convert_state_attributes(state)
if 'children' in state:
cluster_name = "cluster_" + name
is_parallel = isinstance(state.get('initial', ''), list)
sub = container.add_subgraph(name=cluster_name, label=label, rank='source',
**self.machine.style_attributes['graph'][default_style])
root_container = sub.add_subgraph(name=cluster_name + '_root', label='', color=None, rank='min')
width = '0' if is_parallel else '0.1'
root_container.add_node(name + "_anchor", shape='point', fillcolor='black', width=width)
self._add_nodes(state['children'], sub, prefix=prefix + state['name'] + NestedState.separator,
default_style='parallel' if is_parallel else 'default')
else:
container.add_node(name, label=label, **self.machine.style_attributes['node'][default_style])
def _add_edges(self, transitions, container):
for transition in transitions:
# enable customizable labels
label_pos = 'label'
src = transition['source']
try:
dst = transition['dest']
except KeyError:
dst = src
edge_attr = {}
if _get_subgraph(container, 'cluster_' + src) is not None:
edge_attr['ltail'] = 'cluster_' + src
# edge_attr['minlen'] = "3"
src_name = src + "_anchor"
label_pos = 'headlabel'
else:
src_name = src
dst_graph = _get_subgraph(container, 'cluster_' + dst)
if dst_graph is not None:
if not src.startswith(dst):
edge_attr['lhead'] = "cluster_" + dst
label_pos = 'taillabel' if label_pos.startswith('l') else 'label'
dst_name = dst + '_anchor'
else:
dst_name = dst
# remove ltail when dst is a child of src
if 'ltail' in edge_attr:
if _get_subgraph(container, edge_attr['ltail']).has_node(dst_name):
del edge_attr['ltail']
edge_attr[label_pos] = self._transition_label(transition)
if container.has_edge(src_name, dst_name):
edge = container.get_edge(src_name, dst_name)
edge.attr[label_pos] += ' | ' + edge_attr[label_pos]
else:
container.add_edge(src_name, dst_name, **edge_attr)
def set_node_style(self, state, style):
try:
node = self.fsm_graph.get_node(state)
style_attr = self.fsm_graph.style_attributes.get('node', {}).get(style)
node.attr.update(style_attr)
except KeyError:
subgraph = _get_subgraph(self.fsm_graph, 'cluster_' + state)
style_attr = self.fsm_graph.style_attributes.get('graph', {}).get(style)
subgraph.graph_attr.update(style_attr)
def set_previous_transition(self, src, dst, key=None):
src = self._get_global_name(src.split(self.machine.state_cls.separator))
dst = self._get_global_name(dst.split(self.machine.state_cls.separator))
edge_attr = self.fsm_graph.style_attributes.get('edge', {}).get('previous').copy()
try:
edge = self.fsm_graph.get_edge(src, dst)
except KeyError:
_src = src
_dst = dst
if _get_subgraph(self.fsm_graph, 'cluster_' + src):
edge_attr['ltail'] = 'cluster_' + src
_src += '_anchor'
if _get_subgraph(self.fsm_graph, 'cluster_' + dst):
edge_attr['lhead'] = "cluster_" + dst
_dst += '_anchor'
try:
edge = self.fsm_graph.get_edge(_src, _dst)
except KeyError:
self.fsm_graph.add_edge(_src, _dst)
edge = self.fsm_graph.get_edge(_src, _dst)
edge.attr.update(edge_attr)
self.set_node_style(src, 'previous')
def _get_subgraph(graph, name):
""" Searches for subgraphs in a graph.
Args:
g (AGraph): Container to be searched.
name (str): Name of the cluster.
Returns: AGraph if a cluster called 'name' exists else None
"""
sub_graph = graph.get_subgraph(name)
if sub_graph:
return sub_graph
for sub in graph.subgraphs_iter():
sub_graph = _get_subgraph(sub, name)
if sub_graph:
return sub_graph
return None
# the official copy method does not close the file handle
# which causes ResourceWarnings
def _copy_agraph(graph):
from tempfile import TemporaryFile
fh = TemporaryFile()
if hasattr(fh, "file"):
fhandle = fh.file
else:
fhandle = fh
graph.write(fhandle)
fh.seek(0)
res = graph.__class__(filename=fhandle)
fhandle.close()
return res
transitions-0.8.10+3/transitions/extensions/markup.py 0000644 0002322 0002322 00000017662 14155650047 023331 0 ustar debalance debalance from six import string_types, iteritems
from functools import partial
import itertools
import importlib
from ..core import Machine, Enum
import numbers
class MarkupMachine(Machine):
# Special attributes such as NestedState._name/_parent or Transition._condition are handled differently
state_attributes = ['on_exit', 'on_enter', 'ignore_invalid_triggers', 'timeout', 'on_timeout', 'tags', 'label']
transition_attributes = ['source', 'dest', 'prepare', 'before', 'after', 'label']
def __init__(self, *args, **kwargs):
self._markup = kwargs.pop('markup', {})
self._auto_transitions_markup = kwargs.pop('auto_transitions_markup', False)
self._needs_update = True
if self._markup:
models_markup = self._markup.pop('models', [])
super(MarkupMachine, self).__init__(None, **self._markup)
for m in models_markup:
self._add_markup_model(m)
else:
super(MarkupMachine, self).__init__(*args, **kwargs)
self._markup['before_state_change'] = [x for x in (rep(f) for f in self.before_state_change) if x]
self._markup['after_state_change'] = [x for x in (rep(f) for f in self.before_state_change) if x]
self._markup['prepare_event'] = [x for x in (rep(f) for f in self.prepare_event) if x]
self._markup['finalize_event'] = [x for x in (rep(f) for f in self.finalize_event) if x]
self._markup['send_event'] = self.send_event
self._markup['auto_transitions'] = self.auto_transitions
self._markup['ignore_invalid_triggers'] = self.ignore_invalid_triggers
self._markup['queued'] = self.has_queue
@property
def auto_transitions_markup(self):
return self._auto_transitions_markup
@auto_transitions_markup.setter
def auto_transitions_markup(self, value):
self._auto_transitions_markup = value
self._needs_update = True
@property
def markup(self):
self._markup['models'] = self._convert_models()
return self.get_markup_config()
# the only reason why this not part of markup property is that pickle
# has issues with properties during __setattr__ (self.markup is not set)
def get_markup_config(self):
if self._needs_update:
self._convert_states_and_transitions(self._markup)
self._needs_update = False
return self._markup
def add_transition(self, trigger, source, dest, conditions=None,
unless=None, before=None, after=None, prepare=None, **kwargs):
super(MarkupMachine, self).add_transition(trigger, source, dest, conditions=conditions, unless=unless,
before=before, after=after, prepare=prepare, **kwargs)
self._needs_update = True
def add_states(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs):
super(MarkupMachine, self).add_states(states, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers, **kwargs)
self._needs_update = True
@staticmethod
def format_references(func):
try:
return func.__name__
except AttributeError:
pass
if isinstance(func, partial):
return "%s(%s)" % (
func.func.__name__,
", ".join(itertools.chain(
(str(_) for _ in func.args),
("%s=%s" % (key, value)
for key, value in iteritems(func.keywords if func.keywords else {})))))
return str(func)
def _convert_states_and_transitions(self, root):
state = getattr(self, 'scoped', self)
if state.initial:
root['initial'] = state.initial
if state == self and state.name:
root['name'] = self.name[:-2]
self._convert_transitions(root)
self._convert_states(root)
def _convert_states(self, root):
key = 'states' if getattr(self, 'scoped', self) == self else 'children'
root[key] = []
for state_name, state in self.states.items():
s_def = _convert(state, self.state_attributes, self.format_references)
if isinstance(state_name, Enum):
s_def['name'] = state_name.name
else:
s_def['name'] = state_name
if getattr(state, 'states', []):
with self(state_name):
self._convert_states_and_transitions(s_def)
root[key].append(s_def)
def _convert_transitions(self, root):
root['transitions'] = []
for event in self.events.values():
if self._omit_auto_transitions(event):
continue
for transitions in event.transitions.items():
for trans in transitions[1]:
t_def = _convert(trans, self.transition_attributes, self.format_references)
t_def['trigger'] = event.name
con = [x for x in (rep(f.func, self.format_references) for f in trans.conditions
if f.target) if x]
unl = [x for x in (rep(f.func, self.format_references) for f in trans.conditions
if not f.target) if x]
if con:
t_def['conditions'] = con
if unl:
t_def['unless'] = unl
root['transitions'].append(t_def)
def _add_markup_model(self, markup):
initial = markup.get('state', None)
if markup['class-name'] == 'self':
self.add_model(self, initial)
else:
mod_name, cls_name = markup['class-name'].rsplit('.', 1)
cls = getattr(importlib.import_module(mod_name), cls_name)
self.add_model(cls(), initial)
def _convert_models(self):
models = []
for model in self.models:
state = getattr(model, self.model_attribute)
model_def = dict(state=state.name if isinstance(state, Enum) else state)
model_def['name'] = model.name if hasattr(model, 'name') else str(id(model))
model_def['class-name'] = 'self' if model == self else model.__module__ + "." + model.__class__.__name__
models.append(model_def)
return models
def _omit_auto_transitions(self, event):
return self.auto_transitions_markup is False and self._is_auto_transition(event)
# auto transition events commonly a) start with the 'to_' prefix, followed by b) the state name
# and c) contain a transition from each state to the target state (including the target)
def _is_auto_transition(self, event):
if event.name.startswith('to_') and len(event.transitions) == len(self.states):
state_name = event.name[len('to_'):]
try:
_ = self.get_state(state_name)
return True
except ValueError:
pass
return False
@classmethod
def _identify_callback(self, name):
callback_type, target = super(MarkupMachine, self)._identify_callback(name)
if callback_type:
self._needs_update = True
return callback_type, target
def rep(func, format_references=None):
""" Return a string representation for `func`. """
if isinstance(func, string_types):
return func
if isinstance(func, numbers.Number):
return str(func)
return format_references(func) if format_references is not None else None
def _convert(obj, attributes, format_references):
s = {}
for key in attributes:
val = getattr(obj, key, False)
if not val:
continue
if isinstance(val, string_types):
s[key] = val
else:
try:
s[key] = [rep(v, format_references) for v in iter(val)]
except TypeError:
s[key] = rep(val, format_references)
return s
transitions-0.8.10+3/transitions/extensions/nesting.py 0000644 0002322 0002322 00000145150 14155650047 023473 0 ustar debalance debalance # -*- coding: utf-8 -*-
from collections import OrderedDict, defaultdict
import copy
from functools import partial, reduce
import inspect
import logging
from six import string_types
from ..core import State, Machine, Transition, Event, listify, MachineError, Enum, EnumMeta, EventData
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# this is a workaround for dill issues when partials and super is used in conjunction
# without it, Python 3.0 - 3.3 will not support pickling
# https://github.com/pytransitions/transitions/issues/236
_super = super
# converts a hierarchical tree into a list of current states
def _build_state_list(state_tree, separator, prefix=[]):
res = []
for key, value in state_tree.items():
if value:
res.append(_build_state_list(value, separator, prefix=prefix + [key]))
else:
res.append(separator.join(prefix + [key]))
return res if len(res) > 1 else res[0]
# custom breadth-first tree exploration
# makes sure that ALL children are evaluated before parents in parallel states
def _resolve_order(state_tree):
s = state_tree
q = []
res = []
p = []
while True:
for k in reversed(list(s.keys())):
pk = p + [k]
res.append(pk)
if s[k]:
q.append((pk, s[k]))
if not q:
break
p, s = q.pop(0)
return reversed(res)
class FunctionWrapper(object):
""" A wrapper to enable transitions' convenience function to_ for nested states.
This allows to call model.to_A.s1.C() in case a custom separator has been chosen."""
def __init__(self, func, path):
"""
Args:
func: Function to be called at the end of the path.
path: If path is an empty string, assign function
"""
if path:
self.add(func, path)
self._func = None
else:
self._func = func
def add(self, func, path):
""" Assigns a `FunctionWrapper` as an attribute named like the next segment of the substates
path.
Args:
func (callable): Function to be called at the end of the path.
path (string): Remaining segment of the substate path.
"""
if path:
name = path[0]
if name[0].isdigit():
name = 's' + name
if hasattr(self, name):
getattr(self, name).add(func, path[1:])
else:
setattr(self, name, FunctionWrapper(func, path[1:]))
else:
self._func = func
def __call__(self, *args, **kwargs):
return self._func(*args, **kwargs)
class NestedEvent(Event):
""" An event type to work with nested states.
This subclass is NOT compatible with simple Machine instances.
"""
def trigger(self, _model, _machine, *args, **kwargs):
""" Executes all transitions that match the current state,
halting as soon as one successfully completes. More precisely, it prepares a partial
of the internal ``_trigger`` function, passes this to ``machine._process``.
It is up to the machine's configuration of the Event whether processing happens queued (sequentially) or
whether further Events are processed as they occur. NOTE: This should only
be called by HierarchicalMachine instances.
Args:
_model (object): The currently processed model
_machine (HierarchicalMachine): Since NestedEvents can be used in multiple machine instances, this one
will be used to determine the current state separator and the current scope.
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
# Save the current scope (_machine.scoped, _machine.states, _machine.events) in partial
# since queued transitions could otherwise loose their scope.
func = partial(self._trigger, _model, _machine,
(_machine.scoped, _machine.states, _machine.events, _machine.prefix_path),
*args, **kwargs)
# pylint: disable=protected-access
# noinspection PyProtectedMember
# Machine._process should not be called somewhere else. That's why it should not be exposed
# to Machine users.
return _machine._process(func)
def _trigger(self, _model, _machine, _scope, *args, **kwargs):
""" Internal trigger function called by the ``HierarchicalMachine`` instance. This should not
be called directly but via the public method ``HierarchicalMachine.process``. In contrast to
the inherited ``Event._trigger``, this requires a scope tuple to process triggers in the right context.
Args:
_model (object): The currently processed model
_machine (HierarchicalMachine): The machine that should be used to process the event
_scope (Tuple): A tuple containing information about the currently scoped object, states an transitions.
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
if _scope[0] != _machine.scoped:
with _machine(_scope):
return self._trigger_scoped(_model, _machine, *args, **kwargs)
else:
return self._trigger_scoped(_model, _machine, *args, **kwargs)
def _trigger_scoped(self, _model, _machine, *args, **kwargs):
""" Internal scope-adjusted trigger function called by the ``NestedEvent._trigger`` instance. This should not
be called directly.
Args:
_model (object): The currently processed model
_machine (HierarchicalMachine): The machine that should be used to process the event
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
state_tree = _machine._build_state_tree(getattr(_model, _machine.model_attribute), _machine.state_cls.separator)
state_tree = reduce(dict.get, _machine.get_global_name(join=False), state_tree)
ordered_states = _resolve_order(state_tree)
done = set()
res = None
for state_path in ordered_states:
state_name = _machine.state_cls.separator.join(state_path)
if state_name not in done and state_name in self.transitions:
state = _machine.get_state(state_name)
event_data = EventData(state, self, _machine, _model, args=args, kwargs=kwargs)
event_data.source_name = state_name
event_data.source_path = copy.copy(state_path)
res = self._process(event_data)
if res:
elems = state_path
while elems:
done.add(_machine.state_cls.separator.join(elems))
elems.pop()
return res
def _process(self, event_data):
machine = event_data.machine
machine.callbacks(event_data.machine.prepare_event, event_data)
_LOGGER.debug("%sExecuted machine preparation callbacks before conditions.", machine.name)
try:
for trans in self.transitions[event_data.source_name]:
event_data.transition = trans
if trans.execute(event_data):
event_data.result = True
break
except Exception as err:
event_data.error = err
if self.machine.on_exception:
self.machine.callbacks(self.machine.on_exception, event_data)
else:
raise
finally:
try:
machine.callbacks(machine.finalize_event, event_data)
_LOGGER.debug("%sExecuted machine finalize callbacks", machine.name)
except Exception as err:
_LOGGER.error("%sWhile executing finalize callbacks a %s occurred: %s.",
self.machine.name,
type(err).__name__,
str(err))
return event_data.result
class NestedState(State):
""" A state which allows substates.
Attributes:
states (OrderedDict): A list of substates of the current state.
events (dict): A list of events defined for the nested state.
initial (list, str, NestedState or Enum): (Name of a) child or list of children that should be entered when the state is entered.
exit_stack (defaultdict): A list of currently active substates
"""
separator = '_'
u""" Separator between the names of parent and child states. In case '_' is required for
naming state, this value can be set to other values such as '.' or even unicode characters
such as '↦' (limited to Python 3 though).
"""
def __init__(self, name, on_enter=None, on_exit=None, ignore_invalid_triggers=None, initial=None):
_super(NestedState, self).__init__(name=name, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers)
self.initial = initial
self.events = {}
self.states = OrderedDict()
self._scope = []
def add_substate(self, state):
""" Adds a state as a substate.
Args:
state (NestedState): State to add to the current state.
"""
self.add_substates(state)
def add_substates(self, states):
""" Adds a list of states to the current state.
Args:
states (list): List of states to add to the current state.
"""
for state in listify(states):
self.states[state.name] = state
def scoped_enter(self, event_data, scope=[]):
self._scope = scope
try:
self.enter(event_data)
finally:
self._scope = []
def scoped_exit(self, event_data, scope=[]):
self._scope = scope
try:
self.exit(event_data)
finally:
self._scope = []
@property
def name(self):
return self.separator.join(self._scope + [_super(NestedState, self).name])
class NestedTransition(Transition):
""" A transition which handles entering and leaving nested states.
Attributes:
source (str): Source state of the transition.
dest (str): Destination state of the transition.
prepare (list): Callbacks executed before conditions checks.
conditions (list): Callbacks evaluated to determine if
the transition should be executed.
before (list): Callbacks executed before the transition is executed
but only if condition checks have been successful.
after (list): Callbacks executed after the transition is executed
but only if condition checks have been successful.
"""
def _resolve_transition(self, event_data):
machine = event_data.machine
dst_name_path = self.dest.split(event_data.machine.state_cls.separator)
_ = machine.get_state(dst_name_path)
model_states = listify(getattr(event_data.model, machine.model_attribute))
state_tree = machine._build_state_tree(model_states, machine.state_cls.separator)
scope = machine.get_global_name(join=False)
src_name_path = event_data.source_path
if src_name_path == dst_name_path:
root = src_name_path[:-1] # exit and enter the same state
dst_name_path = dst_name_path[-1:]
else:
tmp_tree = state_tree.get(dst_name_path[0], None)
root = []
while tmp_tree is not None:
root.append(dst_name_path.pop(0))
tmp_tree = tmp_tree.get(dst_name_path[0], None) if len(dst_name_path) > 0 else None
scoped_tree = reduce(dict.get, scope + root, state_tree)
exit_partials = [partial(machine.get_state(root + state_name).scoped_exit,
event_data, scope + root + state_name[:-1])
for state_name in _resolve_order(scoped_tree)]
if dst_name_path:
new_states, enter_partials = self._enter_nested(root, dst_name_path, scope + root, event_data)
else:
new_states, enter_partials = {}, []
scoped_tree.clear()
for new_key, value in new_states.items():
scoped_tree[new_key] = value
break
return state_tree, exit_partials, enter_partials
def _change_state(self, event_data):
state_tree, exit_partials, enter_partials = self._resolve_transition(event_data)
for func in exit_partials:
func()
self._update_model(event_data, state_tree)
for func in enter_partials:
func()
def _enter_nested(self, root, dest, prefix_path, event_data):
if root:
state_name = root.pop(0)
with event_data.machine(state_name):
return self._enter_nested(root, dest, prefix_path, event_data)
elif dest:
new_states = OrderedDict()
state_name = dest.pop(0)
with event_data.machine(state_name):
new_states[state_name], new_enter = self._enter_nested([], dest, prefix_path + [state_name], event_data)
enter_partials = [partial(event_data.machine.scoped.scoped_enter, event_data, prefix_path)] + new_enter
return new_states, enter_partials
elif event_data.machine.scoped.initial:
new_states = OrderedDict()
enter_partials = []
q = []
prefix = prefix_path
scoped_tree = new_states
initial_names = [i.name if hasattr(i, 'name') else i for i in listify(event_data.machine.scoped.initial)]
initial_states = [event_data.machine.scoped.states[n] for n in initial_names]
while True:
event_data.scope = prefix
for state in initial_states:
enter_partials.append(partial(state.scoped_enter, event_data, prefix))
scoped_tree[state.name] = OrderedDict()
if state.initial:
q.append((scoped_tree[state.name], prefix + [state.name],
[state.states[i.name] if hasattr(i, 'name') else state.states[i]
for i in listify(state.initial)]))
if not q:
break
scoped_tree, prefix, initial_states = q.pop(0)
return new_states, enter_partials
else:
return {}, []
@staticmethod
def _update_model(event_data, tree):
model_states = _build_state_list(tree, event_data.machine.state_cls.separator)
with event_data.machine():
event_data.machine.set_state(model_states, event_data.model)
states = event_data.machine.get_states(listify(model_states))
event_data.state = states[0] if len(states) == 1 else states
# Prevent deep copying of callback lists since these include either references to callable or
# strings. Deep copying a method reference would lead to the creation of an entire new (model) object
# (see https://github.com/pytransitions/transitions/issues/248)
def __deepcopy__(self, memo):
cls = self.__class__
result = cls.__new__(cls)
memo[id(self)] = result
for key, value in self.__dict__.items():
if key in cls.dynamic_methods:
setattr(result, key, copy.copy(value))
else:
setattr(result, key, copy.deepcopy(value, memo))
return result
class HierarchicalMachine(Machine):
""" Extends transitions.core.Machine by capabilities to handle nested states.
A hierarchical machine REQUIRES NestedStates, NestedEvent and NestedTransitions
(or any subclass of it) to operate.
"""
state_cls = NestedState
transition_cls = NestedTransition
event_cls = NestedEvent
def __init__(self, *args, **kwargs):
assert issubclass(self.state_cls, NestedState)
assert issubclass(self.event_cls, NestedEvent)
assert issubclass(self.transition_cls, NestedTransition)
self._stack = []
self.prefix_path = []
self.scoped = self
_super(HierarchicalMachine, self).__init__(*args, **kwargs)
def __call__(self, to_scope=None):
if isinstance(to_scope, string_types):
state_name = to_scope.split(self.state_cls.separator)[0]
state = self.states[state_name]
to_scope = (state, state.states, state.events, self.prefix_path + [state_name])
elif isinstance(to_scope, Enum):
state = self.states[to_scope.name]
to_scope = (state, state.states, state.events, self.prefix_path + [to_scope.name])
elif to_scope is None:
if self._stack:
to_scope = self._stack[0]
else:
to_scope = (self, self.states, self.events, [])
self._next_scope = to_scope
return self
def __enter__(self):
self._stack.append((self.scoped, self.states, self.events, self.prefix_path))
self.scoped, self.states, self.events, self.prefix_path = self._next_scope
self._next_scope = None
def __exit__(self, exc_type, exc_val, exc_tb):
self.scoped, self.states, self.events, self.prefix_path = self._stack.pop()
def add_model(self, model, initial=None):
""" Extends transitions.core.Machine.add_model by applying a custom 'to' function to
the added model.
"""
models = [self if mod is self.self_literal else mod for mod in listify(model)]
_super(HierarchicalMachine, self).add_model(models, initial=initial)
initial_name = getattr(models[0], self.model_attribute)
if hasattr(initial_name, 'name'):
initial_name = initial_name.name
# initial states set by add_model or machine might contain initial states themselves.
if isinstance(initial_name, string_types):
initial_states = self._resolve_initial(models, initial_name.split(self.state_cls.separator))
# when initial is set to a (parallel) state, we accept it as it is
else:
initial_states = initial_name
for mod in models:
self.set_state(initial_states, mod)
if hasattr(mod, 'to'):
_LOGGER.warning("%sModel already has a 'to'-method. It will NOT "
"be overwritten by NestedMachine", self.name)
else:
to_func = partial(self.to_state, mod)
setattr(mod, 'to', to_func)
@property
def initial(self):
""" Return the initial state. """
return self._initial
@initial.setter
def initial(self, value):
self._initial = self._recursive_initial(value)
def add_ordered_transitions(self, states=None, trigger='next_state',
loop=True, loop_includes_initial=True,
conditions=None, unless=None, before=None,
after=None, prepare=None, **kwargs):
if states is None:
states = self.get_nested_state_names()
_super(HierarchicalMachine, self).add_ordered_transitions(states=states, trigger=trigger, loop=loop,
loop_includes_initial=loop_includes_initial,
conditions=conditions,
unless=unless, before=before, after=after,
prepare=prepare, **kwargs)
def add_states(self, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs):
""" Add new nested state(s).
Args:
states (list, str, dict, Enum, NestedState or Machine): a list, a NestedState instance, the
name of a new state, an enumeration (member) or a dict with keywords to pass on to the
NestedState initializer. If a list, each element can be a string, dict, NestedState or
enumeration member.
on_enter (str or list): callbacks to trigger when the state is
entered. Only valid if first argument is string.
on_exit (str or list): callbacks to trigger when the state is
exited. Only valid if first argument is string.
ignore_invalid_triggers: when True, any calls to trigger methods
that are not valid for the present state (e.g., calling an
a_to_b() trigger when the current state is c) will be silently
ignored rather than raising an invalid transition exception.
Note that this argument takes precedence over the same
argument defined at the Machine level, and is in turn
overridden by any ignore_invalid_triggers explicitly
passed in an individual state's initialization arguments.
**kwargs additional keyword arguments used by state mixins.
"""
remap = kwargs.pop('remap', None)
ignore = self.ignore_invalid_triggers if ignore_invalid_triggers is None else ignore_invalid_triggers
for state in listify(states):
if isinstance(state, Enum):
if isinstance(state.value, EnumMeta):
state = {'name': state, 'children': state.value}
elif isinstance(state.value, dict):
state = dict(name=state, **state.value)
if isinstance(state, string_types):
if remap is not None and state in remap:
return
domains = state.split(self.state_cls.separator, 1)
if len(domains) > 1:
try:
self.get_state(domains[0])
except ValueError:
self.add_state(domains[0], on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, **kwargs)
with self(domains[0]):
self.add_states(domains[1], on_enter=on_enter, on_exit=on_exit, ignore_invalid_triggers=ignore_invalid_triggers, **kwargs)
else:
if state in self.states:
raise ValueError("State {0} cannot be added since it already exists.".format(state))
new_state = self._create_state(state, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore, **kwargs)
self.states[new_state.name] = new_state
self._init_state(new_state)
elif isinstance(state, Enum):
if self.state_cls.separator in state.name:
raise ValueError("State '{0}' contains '{1}' which is used as state name separator. "
"Consider changing the NestedState.separator to avoid this issue."
"".format(state.name, self.state_cls.separator))
if remap is not None and state.name in remap:
return
new_state = self._create_state(state, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore, **kwargs)
if state.name in self.states:
raise ValueError("State {0} cannot be added since it already exists.".format(state.name))
self.states[new_state.name] = new_state
self._init_state(new_state)
elif isinstance(state, dict):
if remap is not None and state['name'] in remap:
return
state = state.copy() # prevent messing with the initially passed dict
remap = state.pop('remap', None)
if 'ignore_invalid_triggers' not in state:
state['ignore_invalid_triggers'] = ignore
# parallel: [states] is just a short handle for {children: [states], initial: [state_names]}
state_parallel = state.pop('parallel', [])
if state_parallel:
state_children = state_parallel
state['initial'] = [s['name'] if isinstance(s, dict)
else s for s in state_children]
else:
state_children = state.pop('children', state.pop('states', []))
transitions = state.pop('transitions', [])
new_state = self._create_state(**state)
self.states[new_state.name] = new_state
self._init_state(new_state)
remapped_transitions = []
with self(new_state.name):
self.add_states(state_children, remap=remap, **kwargs)
if remap is not None:
drop_event = []
for evt in self.events.values():
self.events[evt.name] = copy.copy(evt)
for trigger, event in self.events.items():
drop_source = []
event.transitions = copy.deepcopy(event.transitions)
for source_name, trans_source in event.transitions.items():
if source_name in remap:
drop_source.append(source_name)
continue
drop_trans = []
for trans in trans_source:
if trans.dest in remap:
conditions, unless = [], []
for cond in trans.conditions:
# split a list in two lists based on the accessors (cond.target) truth value
(unless, conditions)[cond.target].append(cond.func)
remapped_transitions.append({
'trigger': trigger,
'source': new_state.name + self.state_cls.separator + trans.source,
'dest': remap[trans.dest],
'conditions': conditions,
'unless': unless,
'prepare': trans.prepare,
'before': trans.before,
'after': trans.after})
drop_trans.append(trans)
for t in drop_trans:
trans_source.remove(t)
if not trans_source:
drop_source.append(source_name)
for s in drop_source:
del event.transitions[s]
if not event.transitions:
drop_event.append(trigger)
for e in drop_event:
del self.events[e]
if transitions:
self.add_transitions(transitions)
self.add_transitions(remapped_transitions)
elif isinstance(state, NestedState):
if state.name in self.states:
raise ValueError("State {0} cannot be added since it already exists.".format(state.name))
self.states[state.name] = state
self._init_state(state)
elif isinstance(state, Machine):
new_states = [s for s in state.states.values() if remap is None or s not in remap]
self.add_states(new_states)
for ev in state.events.values():
self.events[ev.name] = ev
if self.scoped.initial is None:
self.scoped.initial = state.initial
elif isinstance(state, State) and not isinstance(state, NestedState):
raise ValueError("A passed state object must derive from NestedState! "
"A default State object is not sufficient")
else:
raise ValueError("Cannot add state of type {0}. ".format(type(state).__name__))
def add_transition(self, trigger, source, dest, conditions=None,
unless=None, before=None, after=None, prepare=None, **kwargs):
if source != self.wildcard_all:
source = [self.state_cls.separator.join(self._get_enum_path(s)) if isinstance(s, Enum) else s
for s in listify(source)]
if dest != self.wildcard_same:
dest = self.state_cls.separator.join(self._get_enum_path(dest)) if isinstance(dest, Enum) else dest
_super(HierarchicalMachine, self).add_transition(trigger, source, dest, conditions,
unless, before, after, prepare, **kwargs)
def get_global_name(self, state=None, join=True):
domains = copy.copy(self.prefix_path)
if state:
state_name = state.name if hasattr(state, 'name') else state
if state_name in self.states:
domains.append(state_name)
else:
raise ValueError("State '{0}' not found in local states.".format(state))
return self.state_cls.separator.join(domains) if join else domains
def get_nested_state_names(self):
ordered_states = []
for state in self.states.values():
ordered_states.append(self.get_global_name(state))
with self(state.name):
ordered_states.extend(self.get_nested_state_names())
return ordered_states
def get_nested_transitions(self, trigger="", src_path=None, dest_path=None):
if src_path and dest_path:
src = self.state_cls.separator.join(src_path)
dest = self.state_cls.separator.join(dest_path)
transitions = _super(HierarchicalMachine, self).get_transitions(trigger, src, dest)
if len(src_path) > 1 and len(dest_path) > 1:
with self(src_path[0]):
transitions.extend(self.get_nested_transitions(trigger, src_path[1:], dest_path[1:]))
elif src_path:
src = self.state_cls.separator.join(src_path)
transitions = _super(HierarchicalMachine, self).get_transitions(trigger, src, "*")
if len(src_path) > 1:
with self(src_path[0]):
transitions.extend(self.get_nested_transitions(trigger, src_path[1:], None))
elif dest_path:
dest = self.state_cls.separator.join(dest_path)
transitions = _super(HierarchicalMachine, self).get_transitions(trigger, "*", dest)
if len(dest_path) > 1:
for state_name in self.states:
with self(state_name):
transitions.extend(self.get_nested_transitions(trigger, None, dest_path[1:]))
else:
transitions = _super(HierarchicalMachine, self).get_transitions(trigger, "*", "*")
for state_name in self.states:
with self(state_name):
transitions.extend(self.get_nested_transitions(trigger, None, None))
return transitions
def get_nested_triggers(self, src_path=None):
if src_path:
triggers = _super(HierarchicalMachine, self).get_triggers(self.state_cls.separator.join(src_path))
if len(src_path) > 1 and src_path[0] in self.states:
with self(src_path[0]):
triggers.extend(self.get_nested_triggers(src_path[1:]))
else:
triggers = list(self.events.keys())
for state_name in self.states:
with self(state_name):
triggers.extend(self.get_nested_triggers())
return triggers
def get_state(self, state, hint=None):
""" Return the State instance with the passed name. """
if isinstance(state, Enum):
state = self._get_enum_path(state)
elif isinstance(state, string_types):
state = state.split(self.state_cls.separator)
if not hint:
state = copy.copy(state)
hint = copy.copy(state)
if len(state) > 1:
child = state.pop(0)
try:
with self(child):
return self.get_state(state, hint)
except (KeyError, ValueError):
try:
with self():
state = self
for elem in hint:
state = state.states[elem]
return state
except KeyError:
raise ValueError("State '%s' is not a registered state." % self.state_cls.separator.join(hint))
elif state[0] not in self.states:
raise ValueError("State '%s' is not a registered state." % state)
return self.states[state[0]]
def get_states(self, states):
res = []
for state in states:
if isinstance(state, list):
res.append(self.get_states(state))
else:
res.append(self.get_state(state))
return res
def get_transitions(self, trigger="", source="*", dest="*", delegate=False):
""" Return the transitions from the Machine.
Args:
trigger (str): Trigger name of the transition.
source (str, State or Enum): Limits list to transitions from a certain state.
dest (str, State or Enum): Limits list to transitions to a certain state.
delegate (Optional[bool]): If True, consider delegations to parents of source
"""
with self():
source_path = [] if source == "*" \
else source.split(self.state_cls.separator) if isinstance(source, string_types) \
else self._get_enum_path(source) if isinstance(source, Enum) \
else self._get_state_path(source)
dest_path = [] if dest == "*" \
else dest.split(self.state_cls.separator) if isinstance(dest, string_types) \
else self._get_enum_path(dest) if isinstance(dest, Enum) \
else self._get_state_path(dest)
matches = self.get_nested_transitions(trigger, source_path, dest_path)
# only consider delegations when source_path contains a nested state (len > 1)
if delegate is False or len(source_path) < 2:
return matches
source_path.pop()
while source_path:
matches.extend(self.get_transitions(trigger,
source=self.state_cls.separator.join(source_path),
dest=dest))
source_path.pop()
return matches
def get_triggers(self, *args):
""" Extends transitions.core.Machine.get_triggers to also include parent state triggers. """
triggers = []
with self():
for state in args:
state_name = state.name if hasattr(state, 'name') else state
state_path = state_name.split(self.state_cls.separator)
if len(state_path) > 1: # we only need to check substates when 'state_name' refers to a substate
with self(state_path[0]):
triggers.extend(self.get_nested_triggers(state_path[1:]))
while state_path: # check all valid transitions for parent states
triggers.extend(_super(HierarchicalMachine, self).get_triggers(self.state_cls.separator.join(state_path)))
state_path.pop()
return triggers
def has_trigger(self, trigger, state=None):
""" Check whether an event/trigger is known to the machine
Args:
trigger (str): Event/trigger name
state (optional[NestedState]): Limits the recursive search to this state and its children
Returns:
bool: True if event is known and False otherwise
"""
state = state or self
return trigger in state.events or any([self.has_trigger(trigger, sta) for sta in state.states.values()])
def is_state(self, state_name, model, allow_substates=False):
current_name = getattr(model, self.model_attribute)
if allow_substates:
if isinstance(current_name, Enum):
current_name = self.state_cls.separator.join(self._get_enum_path(current_name))
if isinstance(state_name, Enum):
state_name = self.state_cls.separator.join(self._get_enum_path(state_name))
return current_name.startswith(state_name)
return current_name == state_name
def on_enter(self, state_name, callback):
""" Helper function to add callbacks to states in case a custom state separator is used.
Args:
state_name (str): Name of the state
callback (str or callable): Function to be called. Strings will be resolved to model functions.
"""
self.get_state(state_name).add_callback('enter', callback)
def on_exit(self, state_name, callback):
""" Helper function to add callbacks to states in case a custom state separator is used.
Args:
state_name (str): Name of the state
callback (str or callable): Function to be called. Strings will be resolved to model functions.
"""
self.get_state(state_name).add_callback('exit', callback)
def set_state(self, states, model=None):
""" Set the current state.
Args:
states (list of str or Enum or State): value of state(s) to be set
model (optional[object]): targeted model; if not set, all models will be set to 'state'
"""
values = [self._set_state(value) for value in listify(states)]
models = self.models if model is None else listify(model)
for mod in models:
setattr(mod, self.model_attribute, values if len(values) > 1 else values[0])
def to_state(self, model, state_name, *args, **kwargs):
""" Helper function to add go to states in case a custom state separator is used.
Args:
model (class): The model that should be used.
state_name (str): Name of the destination state.
"""
current_state = getattr(model, self.model_attribute)
if isinstance(current_state, list):
raise MachineError("Cannot use 'to_state' from parallel state")
event = EventData(self.get_state(current_state), Event('to', self), self,
model, args=args, kwargs=kwargs)
if isinstance(current_state, Enum):
event.source_path = self._get_enum_path(current_state)
event.source_name = self.state_cls.separator.join(event.source_path)
else:
event.source_name = current_state
event.source_path = current_state.split(self.state_cls.separator)
self._create_transition(event.source_name, state_name).execute(event)
def trigger_event(self, _model, _trigger, *args, **kwargs):
""" Processes events recursively and forwards arguments if suitable events are found.
This function is usually bound to models with model and trigger arguments already
resolved as a partial. Execution will halt when a nested transition has been executed
successfully.
Args:
_model (object): targeted model
_trigger (str): event name
*args: positional parameters passed to the event and its callbacks
**kwargs: keyword arguments passed to the event and its callbacks
Returns:
bool: whether a transition has been executed successfully
Raises:
MachineError: When no suitable transition could be found and ignore_invalid_trigger
is not True. Note that a transition which is not executed due to conditions
is still considered valid.
"""
with self():
res = self._trigger_event(_model, _trigger, None, *args, **kwargs)
return self._check_event_result(res, _model, _trigger)
def _add_model_to_state(self, state, model):
name = self.get_global_name(state)
if self.state_cls.separator == '_':
value = state.value if isinstance(state.value, Enum) else name
self._checked_assignment(model, 'is_%s' % name, partial(self.is_state, value, model))
# Add dynamic method callbacks (enter/exit) if there are existing bound methods in the model
# except if they are already mentioned in 'on_enter/exit' of the defined state
for callback in self.state_cls.dynamic_methods:
method = "{0}_{1}".format(callback, name)
if hasattr(model, method) and inspect.ismethod(getattr(model, method)) and \
method not in getattr(state, callback):
state.add_callback(callback[3:], method)
else:
path = name.split(self.state_cls.separator)
value = state.value if isinstance(state.value, Enum) else name
trig_func = partial(self.is_state, value, model)
if hasattr(model, 'is_' + path[0]):
getattr(model, 'is_' + path[0]).add(trig_func, path[1:])
else:
self._checked_assignment(model, 'is_' + path[0], FunctionWrapper(trig_func, path[1:]))
with self(state.name):
for event in self.events.values():
if not hasattr(model, event.name):
self._add_trigger_to_model(event.name, model)
for state in self.states.values():
self._add_model_to_state(state, model)
def _add_trigger_to_model(self, trigger, model):
trig_func = partial(self.trigger_event, model, trigger)
# FunctionWrappers are only necessary if a custom separator is used
if trigger.startswith('to_') and self.state_cls.separator != '_':
path = trigger[3:].split(self.state_cls.separator)
if hasattr(model, 'to_' + path[0]):
# add path to existing function wrapper
getattr(model, 'to_' + path[0]).add(trig_func, path[1:])
else:
# create a new function wrapper
self._checked_assignment(model, 'to_' + path[0], FunctionWrapper(trig_func, path[1:]))
else:
self._checked_assignment(model, trigger, trig_func)
# converts a list of current states into a hierarchical state tree
def _build_state_tree(self, model_states, separator, tree=None):
tree = tree if tree is not None else OrderedDict()
if isinstance(model_states, list):
for state in model_states:
_ = self._build_state_tree(state, separator, tree)
else:
tmp = tree
if isinstance(model_states, (Enum, EnumMeta)):
with self():
path = self._get_enum_path(model_states)
else:
path = model_states.split(separator)
for elem in path:
tmp = tmp.setdefault(elem.name if hasattr(elem, 'name') else elem, OrderedDict())
return tree
def _get_enum_path(self, enum_state, prefix=[]):
if enum_state.name in self.states and self.states[enum_state.name].value == enum_state:
return prefix + [enum_state.name]
for name in self.states:
with self(name):
res = self._get_enum_path(enum_state, prefix=prefix + [name])
if res:
return res
return []
def _get_state_path(self, state, prefix=[]):
if state in self.states.values():
return prefix + [state.name]
for name in self.states:
with self(name):
res = self._get_state_path(state, prefix=prefix + [name])
if res:
return res
return []
def _check_event_result(self, res, model, trigger):
if res is None:
state_names = getattr(model, self.model_attribute)
msg = "%sCan't trigger event '%s' from state(s) %s!" % (self.name, trigger, state_names)
for state_name in listify(state_names):
state = self.get_state(state_name)
ignore = state.ignore_invalid_triggers if state.ignore_invalid_triggers is not None \
else self.ignore_invalid_triggers
if not ignore:
# determine whether a MachineError (valid event but invalid state) ...
if self.has_trigger(trigger):
raise MachineError(msg)
# or AttributeError (invalid event) is appropriate
else:
raise AttributeError("Do not know event named '%s'." % trigger)
_LOGGER.warning(msg)
res = False
return res
def _get_trigger(self, model, trigger_name, *args, **kwargs):
"""Convenience function added to the model to trigger events by name.
Args:
model (object): Model with assigned event trigger.
trigger_name (str): Name of the trigger to be called.
*args: Variable length argument list which is passed to the triggered event.
**kwargs: Arbitrary keyword arguments which is passed to the triggered event.
Returns:
bool: True if a transitions has been conducted or the trigger event has been queued.
"""
return self.trigger_event(model, trigger_name, *args, **kwargs)
def _has_state(self, state, raise_error=False):
""" This function
Args:
state (NestedState): state to be tested
raise_error (bool): whether ValueError should be raised when the state
is not registered
Returns:
bool: Whether state is registered in the machine
Raises:
ValueError: When raise_error is True and state is not registered
"""
found = _super(HierarchicalMachine, self)._has_state(state)
if not found:
for a_state in self.states:
with self(a_state):
if self._has_state(state):
return True
if not found and raise_error:
msg = 'State %s has not been added to the machine' % (state.name if hasattr(state, 'name') else state)
raise ValueError(msg)
return found
def _init_state(self, state):
for model in self.models:
self._add_model_to_state(state, model)
if self.auto_transitions:
state_name = self.get_global_name(state.name)
parent = state_name.split(self.state_cls.separator, 1)
with self():
for a_state in self.get_nested_state_names():
if a_state == parent[0]:
self.add_transition('to_%s' % state_name, self.wildcard_all, state_name)
elif len(parent) == 1:
self.add_transition('to_%s' % a_state, state_name, a_state)
with self(state.name):
for substate in self.states.values():
self._init_state(substate)
def _recursive_initial(self, value):
if isinstance(value, string_types):
path = value.split(self.state_cls.separator, 1)
if len(path) > 1:
state_name, suffix = path
# make sure the passed state has been created already
_super(HierarchicalMachine, self.__class__).initial.fset(self, state_name)
with self(state_name):
self.initial = suffix
self._initial = state_name + self.state_cls.separator + self._initial
else:
_super(HierarchicalMachine, self.__class__).initial.fset(self, value)
elif isinstance(value, (list, tuple)):
return [self._recursive_initial(v) for v in value]
else:
_super(HierarchicalMachine, self.__class__).initial.fset(self, value)
return self._initial[0] if isinstance(self._initial, list) and len(self._initial) == 1 else self._initial
def _resolve_initial(self, models, state_name_path, prefix=[]):
if state_name_path:
state_name = state_name_path.pop(0)
with self(state_name):
return self._resolve_initial(models, state_name_path, prefix=prefix + [state_name])
if self.scoped.initial:
entered_states = []
for initial_state_name in listify(self.scoped.initial):
with self(initial_state_name):
entered_states.append(self._resolve_initial(models, [], prefix=prefix + [self.scoped.name]))
return entered_states if len(entered_states) > 1 else entered_states[0]
return self.state_cls.separator.join(prefix)
def _set_state(self, state_name):
if isinstance(state_name, list):
return [self._set_state(value) for value in state_name]
else:
a_state = self.get_state(state_name)
return a_state.value if isinstance(a_state.value, Enum) else state_name
def _trigger_event(self, _model, _trigger, _state_tree, *args, **kwargs):
if _state_tree is None:
_state_tree = self._build_state_tree(listify(getattr(_model, self.model_attribute)),
self.state_cls.separator)
res = {}
for key, value in _state_tree.items():
if value:
with self(key):
tmp = self._trigger_event(_model, _trigger, value, *args, **kwargs)
if tmp is not None:
res[key] = tmp
if res.get(key, False) is False and _trigger in self.events:
tmp = self.events[_trigger].trigger(_model, self, *args, **kwargs)
if tmp is not None:
res[key] = tmp
return None if not res or all(v is None for v in res.values()) else any(res.values())
transitions-0.8.10+3/transitions/extensions/nesting_legacy.py 0000644 0002322 0002322 00000054161 14155650047 025020 0 ustar debalance debalance # -*- coding: utf-8 -*-
"""
transitions.extensions.nesting
------------------------------
Adds the capability to work with nested states also known as hierarchical state machines.
"""
from copy import copy, deepcopy
from functools import partial
import logging
from six import string_types
from ..core import Machine, Transition, State, Event, listify, MachineError, EventData, Enum
from .nesting import FunctionWrapper
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# This is a workaround for dill issues when partials and super is used in conjunction
# without it, Python 3.0 - 3.3 will not support pickling
# https://github.com/pytransitions/transitions/issues/236
_super = super
class NestedState(State):
""" A state which allows substates.
Attributes:
parent (NestedState): The parent of the current state.
children (list): A list of child states of the current state.
"""
separator = '_'
u""" Separator between the names of parent and child states. In case '_' is required for
naming state, this value can be set to other values such as '.' or even unicode characters
such as '↦' (limited to Python 3 though).
"""
def __init__(self, name, on_enter=None, on_exit=None, ignore_invalid_triggers=None, parent=None, initial=None):
if parent is not None and isinstance(name, Enum):
raise AttributeError("NestedState does not support nested enumerations.")
self._initial = initial
self._parent = None
self.parent = parent
_super(NestedState, self).__init__(name=name, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers)
self.children = []
@property
def parent(self):
""" The parent state of this state. """
return self._parent
@parent.setter
def parent(self, value):
if value is not None:
self._parent = value
self._parent.children.append(self)
@property
def initial(self):
""" When this state is entered it will automatically enter
the child with this name if not None. """
return self.name + self.separator + self._initial if self._initial else self._initial
@initial.setter
def initial(self, value):
self._initial = value
@property
def level(self):
""" Tracks how deeply nested this state is. This property is calculated from
the state's parent (+1) or 0 when there is no parent. """
return self.parent.level + 1 if self.parent is not None else 0
@property
def name(self):
""" The computed name of this state. """
if self.parent:
return self.parent.name + self.separator + _super(NestedState, self).name
return _super(NestedState, self).name
@name.setter
def name(self, value):
self._name = value
@property
def value(self):
return self.name if isinstance(self._name, string_types) else _super(NestedState, self).value
def is_substate_of(self, state_name):
"""Check whether this state is a substate of a state named `state_name`
Args:
state_name (str): Name of the parent state to be checked
Returns: bool True when `state_name` is a parent of this state
"""
temp_state = self
while not temp_state.value == state_name and temp_state.level > 0:
temp_state = temp_state.parent
return temp_state.value == state_name
def exit_nested(self, event_data, target_state):
""" Tracks child states to exit when the states is exited itself. This should not
be triggered by the user but will be handled by the hierarchical machine.
Args:
event_data (EventData): Event related data.
target_state (NestedState): The state to be entered.
Returns: int level of the currently investigated (sub)state.
"""
if self == target_state:
self.exit(event_data)
return self.level
elif self.level > target_state.level:
self.exit(event_data)
return self.parent.exit_nested(event_data, target_state)
elif self.level <= target_state.level:
tmp_state = target_state
while self.level != tmp_state.level:
tmp_state = tmp_state.parent
tmp_self = self
while tmp_self.level > 0 and tmp_state.parent.name != tmp_self.parent.name:
tmp_self.exit(event_data)
tmp_self = tmp_self.parent
tmp_state = tmp_state.parent
if tmp_self == tmp_state:
return tmp_self.level + 1
tmp_self.exit(event_data)
return tmp_self.level
def enter_nested(self, event_data, level=None):
""" Tracks parent states to be entered when the states is entered itself. This should not
be triggered by the user but will be handled by the hierarchical machine.
Args:
event_data (EventData): Event related data.
level (int): The level of the currently entered parent.
"""
if level is not None and level <= self.level:
if level != self.level:
self.parent.enter_nested(event_data, level)
self.enter(event_data)
# Prevent deep copying of callback lists since these include either references to callables or
# strings. Deep copying a method reference would lead to the creation of an entire new (model) object
# (see https://github.com/pytransitions/transitions/issues/248)
def __deepcopy__(self, memo):
cls = self.__class__
result = cls.__new__(cls)
memo[id(self)] = result
for key, value in self.__dict__.items():
if key in cls.dynamic_methods:
setattr(result, key, copy(value))
else:
setattr(result, key, deepcopy(value, memo))
return result
class NestedTransition(Transition):
""" A transition which handles entering and leaving nested states.
Attributes:
dest (NestedState): The resolved transition destination in respect
to initial states of nested states.
"""
def execute(self, event_data):
""" Extends transitions.core.transitions to handle nested states. """
if self.dest is None:
return _super(NestedTransition, self).execute(event_data)
dest_state = event_data.machine.get_state(self.dest)
while dest_state.initial:
dest_state = event_data.machine.get_state(dest_state.initial)
self.dest = dest_state.name
return _super(NestedTransition, self).execute(event_data)
# The actual state change method 'execute' in Transition was restructured to allow overriding
def _change_state(self, event_data):
machine = event_data.machine
model = event_data.model
dest_state = machine.get_state(self.dest)
source_state = machine.get_model_state(model)
lvl = source_state.exit_nested(event_data, dest_state)
event_data.machine.set_state(self.dest, model)
event_data.update(dest_state)
dest_state.enter_nested(event_data, lvl)
# Prevent deep copying of callback lists since these include either references to callable or
# strings. Deep copying a method reference would lead to the creation of an entire new (model) object
# (see https://github.com/pytransitions/transitions/issues/248)
def __deepcopy__(self, memo):
cls = self.__class__
result = cls.__new__(cls)
memo[id(self)] = result
for key, value in self.__dict__.items():
if key in cls.dynamic_methods:
setattr(result, key, copy(value))
else:
setattr(result, key, deepcopy(value, memo))
return result
class NestedEvent(Event):
""" An event type to work with nested states. """
def _trigger(self, model, *args, **kwargs):
state = self.machine.get_model_state(model)
while state.parent and state.name not in self.transitions:
state = state.parent
if state.name not in self.transitions:
msg = "%sCan't trigger event %s from state %s!" % (self.machine.name, self.name,
self.machine.get_model_state(model))
if self.machine.get_model_state(model).ignore_invalid_triggers:
_LOGGER.warning(msg)
else:
raise MachineError(msg)
event_data = EventData(state, self, self.machine,
model, args=args, kwargs=kwargs)
return self._process(event_data)
class HierarchicalMachine(Machine):
""" Extends transitions.core.Machine by capabilities to handle nested states.
A hierarchical machine REQUIRES NestedStates (or any subclass of it) to operate.
"""
state_cls = NestedState
transition_cls = NestedTransition
event_cls = NestedEvent
def __init__(self, *args, **kwargs):
self._buffered_transitions = []
_super(HierarchicalMachine, self).__init__(*args, **kwargs)
@Machine.initial.setter
def initial(self, value):
if isinstance(value, NestedState):
if value.name not in self.states:
self.add_state(value)
else:
assert self._has_state(value)
state = value
else:
state_name = value.name if isinstance(value, Enum) else value
if state_name not in self.states:
self.add_state(state_name)
state = self.get_state(state_name)
if state.initial:
self.initial = state.initial
else:
self._initial = state.name
def add_model(self, model, initial=None):
""" Extends transitions.core.Machine.add_model by applying a custom 'to' function to
the added model.
"""
_super(HierarchicalMachine, self).add_model(model, initial=initial)
models = listify(model)
for mod in models:
mod = self if mod is self.self_literal else mod
# TODO: Remove 'mod != self' in 0.7.0
if hasattr(mod, 'to') and mod != self:
_LOGGER.warning("%sModel already has a 'to'-method. It will NOT "
"be overwritten by NestedMachine", self.name)
else:
to_func = partial(self.to_state, mod)
setattr(mod, 'to', to_func)
def is_state(self, state_name, model, allow_substates=False):
""" Extends transitions.core.Machine.is_state with an additional parameter (allow_substates)
to
Args:
state_name (str): Name of the checked state.
model (class): The model to be investigated.
allow_substates (bool): Whether substates should be allowed or not.
Returns: bool Whether the passed model is in queried state (or a substate of it) or not.
"""
if not allow_substates:
return getattr(model, self.model_attribute) == state_name
return self.get_model_state(model).is_substate_of(state_name)
def _traverse(self, states, on_enter=None, on_exit=None,
ignore_invalid_triggers=None, parent=None, remap=None):
""" Parses passed value to build a nested state structure recursively.
Args:
states (list, str, dict, or State): a list, a State instance, the
name of a new state, or a dict with keywords to pass on to the
State initializer. If a list, each element can be of any of the
latter three types.
on_enter (str or list): callbacks to trigger when the state is
entered. Only valid if first argument is string.
on_exit (str or list): callbacks to trigger when the state is
exited. Only valid if first argument is string.
ignore_invalid_triggers: when True, any calls to trigger methods
that are not valid for the present state (e.g., calling an
a_to_b() trigger when the current state is c) will be silently
ignored rather than raising an invalid transition exception.
Note that this argument takes precedence over the same
argument defined at the Machine level, and is in turn
overridden by any ignore_invalid_triggers explicitly
passed in an individual state's initialization arguments.
parent (NestedState or str): parent state for nested states.
remap (dict): reassigns transitions named `key from nested machines to parent state `value`.
Returns: list of new `NestedState` objects
"""
states = listify(states)
new_states = []
ignore = ignore_invalid_triggers
remap = {} if remap is None else remap
parent = self.get_state(parent) if isinstance(parent, (string_types, Enum)) else parent
if ignore is None:
ignore = self.ignore_invalid_triggers
for state in states:
tmp_states = []
# other state representations are handled almost like in the base class but a parent parameter is added
if isinstance(state, (string_types, Enum)):
if state in remap:
continue
tmp_states.append(self._create_state(state, on_enter=on_enter, on_exit=on_exit, parent=parent,
ignore_invalid_triggers=ignore))
elif isinstance(state, dict):
if state['name'] in remap:
continue
# shallow copy the dictionary to alter/add some parameters
state = copy(state)
if 'ignore_invalid_triggers' not in state:
state['ignore_invalid_triggers'] = ignore
if 'parent' not in state:
state['parent'] = parent
try:
state_children = state.pop('children') # throws KeyError when no children set
state_remap = state.pop('remap', None)
state_parent = self._create_state(**state)
nested = self._traverse(state_children, parent=state_parent, remap=state_remap)
tmp_states.append(state_parent)
tmp_states.extend(nested)
except KeyError:
tmp_states.insert(0, self._create_state(**state))
elif isinstance(state, HierarchicalMachine):
# set initial state of parent if it is None
if parent.initial is None:
parent.initial = state.initial
# (deep) copy only states not mentioned in remap
copied_states = [s for s in deepcopy(state.states).values() if s.name not in remap]
# inner_states are the root states of the passed machine
# which have be attached to the parent
inner_states = [s for s in copied_states if s.level == 0]
for inner in inner_states:
inner.parent = parent
tmp_states.extend(copied_states)
for trigger, event in state.events.items():
if trigger.startswith('to_'):
path = trigger[3:].split(self.state_cls.separator)
# do not copy auto_transitions since they would not be valid anymore;
# trigger and destination do not exist in the new environment
if path[0] in remap:
continue
ppath = parent.name.split(self.state_cls.separator)
path = ['to_' + ppath[0]] + ppath[1:] + path
trigger = '.'.join(path)
# (deep) copy transitions and
# adjust all transition start and end points to new state names
for transitions in deepcopy(event.transitions).values():
for transition in transitions:
src = transition.source
# transitions from remapped states will be filtered to prevent
# unexpected behaviour in the parent machine
if src in remap:
continue
dst = parent.name + self.state_cls.separator + transition.dest\
if transition.dest not in remap else remap[transition.dest]
conditions, unless = [], []
for cond in transition.conditions:
# split a list in two lists based on the accessors (cond.target) truth value
(unless, conditions)[cond.target].append(cond.func)
self._buffered_transitions.append({'trigger': trigger,
'source': parent.name + self.state_cls.separator + src,
'dest': dst,
'conditions': conditions,
'unless': unless,
'prepare': transition.prepare,
'before': transition.before,
'after': transition.after})
elif isinstance(state, NestedState):
tmp_states.append(state)
if state.children:
tmp_states.extend(self._traverse(state.children, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers,
parent=state, remap=remap))
else:
raise ValueError("%s is not an instance or subclass of NestedState "
"required by HierarchicalMachine." % state)
new_states.extend(tmp_states)
duplicate_check = []
for new in new_states:
if new.name in duplicate_check:
# collect state names for the following error message
state_names = [s.name for s in new_states]
raise ValueError("State %s cannot be added since it is already in state list %s."
% (new.name, state_names))
else:
duplicate_check.append(new.name)
return new_states
def add_states(self, states, on_enter=None, on_exit=None,
ignore_invalid_triggers=None, **kwargs):
""" Extends transitions.core.Machine.add_states by calling traverse to parse possible
substates first."""
# preprocess states to flatten the configuration and resolve nesting
new_states = self._traverse(states, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers, **kwargs)
_super(HierarchicalMachine, self).add_states(new_states, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers,
**kwargs)
while self._buffered_transitions:
args = self._buffered_transitions.pop(0)
self.add_transition(**args)
def get_nested_state_names(self):
""" Returns all states of the state machine. """
return self.states
def get_triggers(self, *args):
""" Extends transitions.core.Machine.get_triggers to also include parent state triggers. """
# add parents to state set
states = []
for state_name in args:
state = self.get_state(state_name)
while state.parent:
states.append(state.parent.name)
state = state.parent
states.extend(args)
return _super(HierarchicalMachine, self).get_triggers(*states)
def _add_trigger_to_model(self, trigger, model):
# FunctionWrappers are only necessary if a custom separator is used
if trigger.startswith('to_') and self.state_cls.separator != '_':
path = trigger[3:].split(self.state_cls.separator)
trig_func = partial(self.events[trigger].trigger, model)
if hasattr(model, 'to_' + path[0]):
# add path to existing function wrapper
getattr(model, 'to_' + path[0]).add(trig_func, path[1:])
else:
# create a new function wrapper
setattr(model, 'to_' + path[0], FunctionWrapper(trig_func, path[1:]))
else:
_super(HierarchicalMachine, self)._add_trigger_to_model(trigger, model) # pylint: disable=protected-access
def on_enter(self, state_name, callback):
""" Helper function to add callbacks to states in case a custom state separator is used.
Args:
state_name (str): Name of the state
callback (str or callable): Function to be called. Strings will be resolved to model functions.
"""
self.get_state(state_name).add_callback('enter', callback)
def on_exit(self, state_name, callback):
""" Helper function to add callbacks to states in case a custom state separator is used.
Args:
state_name (str): Name of the state
callback (str or callable): Function to be called. Strings will be resolved to model functions.
"""
self.get_state(state_name).add_callback('exit', callback)
def to_state(self, model, state_name, *args, **kwargs):
""" Helper function to add go to states in case a custom state separator is used.
Args:
model (class): The model that should be used.
state_name (str): Name of the destination state.
"""
event = EventData(self.get_model_state(model), Event('to', self), self,
model, args=args, kwargs=kwargs)
self._create_transition(getattr(model, self.model_attribute), state_name).execute(event)
transitions-0.8.10+3/transitions/extensions/states.py 0000644 0002322 0002322 00000015655 14155650047 023335 0 ustar debalance debalance """
transitions.extensions.states
-----------------------------
This module contains mix ins which can be used to extend state functionality.
"""
from threading import Timer
import logging
import inspect
from ..core import MachineError, listify, State
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
class Tags(State):
""" Allows states to be tagged.
Attributes:
tags (list): A list of tag strings. `State.is_` may be used
to check if is in the list.
"""
def __init__(self, *args, **kwargs):
"""
Args:
**kwargs: If kwargs contains `tags`, assign them to the attribute.
"""
self.tags = kwargs.pop('tags', [])
super(Tags, self).__init__(*args, **kwargs)
def __getattr__(self, item):
if item.startswith('is_'):
return item[3:] in self.tags
return super(Tags, self).__getattribute__(item)
class Error(Tags):
""" This mix in builds upon tag and should be used INSTEAD of Tags if final states that have
not been tagged with 'accepted' should throw an `MachineError`.
"""
def __init__(self, *args, **kwargs):
"""
Args:
**kwargs: If kwargs contains the keywork `accepted` add the 'accepted' tag to a tag list
which will be forwarded to the Tags constructor.
"""
tags = kwargs.get('tags', [])
accepted = kwargs.pop('accepted', False)
if accepted:
tags.append('accepted')
kwargs['tags'] = tags
super(Error, self).__init__(*args, **kwargs)
def enter(self, event_data):
""" Extends transitions.core.State.enter. Throws a `MachineError` if there is
no leaving transition from this state and 'accepted' is not in self.tags.
"""
if not event_data.machine.get_triggers(self.name) and not self.is_accepted:
raise MachineError("Error state '{0}' reached!".format(self.name))
super(Error, self).enter(event_data)
class Timeout(State):
""" Adds timeout functionality to a state. Timeouts are handled model-specific.
Attributes:
timeout (float): Seconds after which a timeout function should be called.
on_timeout (list): Functions to call when a timeout is triggered.
"""
dynamic_methods = ['on_timeout']
def __init__(self, *args, **kwargs):
"""
Args:
**kwargs: If kwargs contain 'timeout', assign the float value to self.timeout. If timeout
is set, 'on_timeout' needs to be passed with kwargs as well or an AttributeError will
be thrown. If timeout is not passed or equal 0.
"""
self.timeout = kwargs.pop('timeout', 0)
self._on_timeout = None
if self.timeout > 0:
try:
self.on_timeout = kwargs.pop('on_timeout')
except KeyError:
raise AttributeError("Timeout state requires 'on_timeout' when timeout is set.")
else:
self._on_timeout = kwargs.pop('on_timeout', [])
self.runner = {}
super(Timeout, self).__init__(*args, **kwargs)
def enter(self, event_data):
""" Extends `transitions.core.State.enter` by starting a timeout timer for the current model
when the state is entered and self.timeout is larger than 0.
"""
if self.timeout > 0:
timer = Timer(self.timeout, self._process_timeout, args=(event_data,))
timer.daemon = True
timer.start()
self.runner[id(event_data.model)] = timer
return super(Timeout, self).enter(event_data)
def exit(self, event_data):
""" Extends `transitions.core.State.exit` by canceling a timer for the current model. """
timer = self.runner.get(id(event_data.model), None)
if timer is not None and timer.is_alive():
timer.cancel()
return super(Timeout, self).exit(event_data)
def _process_timeout(self, event_data):
_LOGGER.debug("%sTimeout state %s. Processing callbacks...", event_data.machine.name, self.name)
for callback in self.on_timeout:
event_data.machine.callback(callback, event_data)
_LOGGER.info("%sTimeout state %s processed.", event_data.machine.name, self.name)
@property
def on_timeout(self):
""" List of strings and callables to be called when the state timeouts. """
return self._on_timeout
@on_timeout.setter
def on_timeout(self, value):
""" Listifies passed values and assigns them to on_timeout."""
self._on_timeout = listify(value)
class Volatile(State):
""" Adds scopes/temporal variables to the otherwise persistent state objects.
Attributes:
volatile_cls (cls): Class of the temporal object to be initiated.
volatile_hook (str): Model attribute name which will contain the volatile instance.
"""
def __init__(self, *args, **kwargs):
"""
Args:
**kwargs: If kwargs contains `volatile`, always create an instance of the passed class
whenever the state is entered. The instance is assigned to a model attribute which
can be passed with the kwargs keyword `hook`. If hook is not passed, the instance will
be assigned to the 'attribute' scope. If `volatile` is not passed, an empty object will
be assigned to the model's hook.
"""
self.volatile_cls = kwargs.pop('volatile', VolatileObject)
self.volatile_hook = kwargs.pop('hook', 'scope')
super(Volatile, self).__init__(*args, **kwargs)
self.initialized = True
def enter(self, event_data):
""" Extends `transitions.core.State.enter` by creating a volatile object and assign it to
the current model's hook. """
setattr(event_data.model, self.volatile_hook, self.volatile_cls())
super(Volatile, self).enter(event_data)
def exit(self, event_data):
""" Extends `transitions.core.State.exit` by deleting the temporal object from the model. """
super(Volatile, self).exit(event_data)
try:
delattr(event_data.model, self.volatile_hook)
except AttributeError:
pass
def add_state_features(*args):
""" State feature decorator. Should be used in conjunction with a custom Machine class. """
def _class_decorator(cls):
class CustomState(type('CustomState', args, {}), cls.state_cls):
""" The decorated State. It is based on the State class used by the decorated Machine. """
pass
method_list = sum([c.dynamic_methods for c in inspect.getmro(CustomState) if hasattr(c, 'dynamic_methods')], [])
CustomState.dynamic_methods = list(set(method_list))
cls.state_cls = CustomState
return cls
return _class_decorator
class VolatileObject(object):
""" Empty Python object which can be used to assign attributes to."""
pass
transitions-0.8.10+3/transitions/extensions/locking.py 0000644 0002322 0002322 00000016521 14155650047 023451 0 ustar debalance debalance """
transitions.extensions.factory
------------------------------
Adds locking to machine methods as well as model functions that trigger events.
Additionally, the user can inject her/his own context manager into the machine if required.
"""
from collections import defaultdict
from functools import partial
from threading import Lock
import inspect
import warnings
import logging
from transitions.core import Machine, Event, listify
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# this is a workaround for dill issues when partials and super is used in conjunction
# without it, Python 3.0 - 3.3 will not support pickling
# https://github.com/pytransitions/transitions/issues/236
_super = super
try:
from contextlib import nested # Python 2
from thread import get_ident
# with nested statements now raise a DeprecationWarning. Should be replaced with ExitStack-like approaches.
warnings.simplefilter('ignore', DeprecationWarning)
except ImportError:
from contextlib import ExitStack, contextmanager
from threading import get_ident
@contextmanager
def nested(*contexts):
""" Reimplementation of nested in Python 3. """
with ExitStack() as stack:
for ctx in contexts:
stack.enter_context(ctx)
yield contexts
class PicklableLock(object):
""" A wrapper for threading.Lock which discards its state during pickling and
is reinitialized unlocked when unpickled.
"""
def __init__(self):
self.lock = Lock()
def __getstate__(self):
return ''
def __setstate__(self, value):
return self.__init__()
def __enter__(self):
self.lock.__enter__()
def __exit__(self, exc_type, exc_val, exc_tb):
self.lock.__exit__(exc_type, exc_val, exc_tb)
class IdentManager:
def __init__(self):
self.current = 0
def __enter__(self):
self.current = get_ident()
pass
def __exit__(self, exc_type, exc_val, exc_tb):
self.current = 0
class LockedEvent(Event):
""" An event type which uses the parent's machine context map when triggered. """
def trigger(self, model, *args, **kwargs):
""" Extends transitions.core.Event.trigger by using locks/machine contexts. """
# pylint: disable=protected-access
# noinspection PyProtectedMember
# LockedMachine._locked should not be called somewhere else. That's why it should not be exposed
# to Machine users.
if self.machine._ident.current != get_ident():
with nested(*self.machine.model_context_map[id(model)]):
return _super(LockedEvent, self).trigger(model, *args, **kwargs)
else:
return _super(LockedEvent, self).trigger(model, *args, **kwargs)
class LockedMachine(Machine):
""" Machine class which manages contexts. In it's default version the machine uses a `threading.Lock`
context to lock access to its methods and event triggers bound to model objects.
Attributes:
machine_context (dict): A dict of context managers to be entered whenever a machine method is
called or an event is triggered. Contexts are managed for each model individually.
"""
event_cls = LockedEvent
def __init__(self, *args, **kwargs):
self._ident = IdentManager()
try:
self.machine_context = listify(kwargs.pop('machine_context'))
except KeyError:
self.machine_context = [PicklableLock()]
self.machine_context.append(self._ident)
self.model_context_map = defaultdict(list)
_super(LockedMachine, self).__init__(*args, **kwargs)
# When we attempt to pickle a locked machine, using IDs wont suffice to unpickle the contexts since
# IDs have changed. We use a 'reference' store with objects as dictionary keys to resolve the newly created
# references. This should induce no restrictions compared to transitions 0.8.8 but enable the usage of unhashable
# objects in locked machine.
def __getstate__(self):
state = {k: v for k, v in self.__dict__.items()}
del state['model_context_map']
state['_model_context_map_store'] = {mod: self.model_context_map[id(mod)] for mod in self.models}
return state
def __setstate__(self, state):
self.__dict__.update(state)
self.model_context_map = defaultdict(list)
for model in self.models:
self.model_context_map[id(model)] = self._model_context_map_store[model]
del self._model_context_map_store
def add_model(self, model, initial=None, model_context=None):
""" Extends `transitions.core.Machine.add_model` by `model_context` keyword.
Args:
model (list or object): A model (list) to be managed by the machine.
initial (str, Enum or State): The initial state of the passed model[s].
model_context (list or object): If passed, assign the context (list) to the machines
model specific context map.
"""
models = listify(model)
model_context = listify(model_context) if model_context is not None else []
output = _super(LockedMachine, self).add_model(models, initial)
for mod in models:
mod = self if mod is self.self_literal else mod
self.model_context_map[id(mod)].extend(self.machine_context)
self.model_context_map[id(mod)].extend(model_context)
return output
def remove_model(self, model):
""" Extends `transitions.core.Machine.remove_model` by removing model specific context maps
from the machine when the model itself is removed. """
models = listify(model)
for mod in models:
del self.model_context_map[id(mod)]
return _super(LockedMachine, self).remove_model(models)
def __getattribute__(self, item):
get_attr = _super(LockedMachine, self).__getattribute__
tmp = get_attr(item)
if not item.startswith('_') and inspect.ismethod(tmp):
return partial(get_attr('_locked_method'), tmp)
return tmp
def __getattr__(self, item):
try:
return _super(LockedMachine, self).__getattribute__(item)
except AttributeError:
return _super(LockedMachine, self).__getattr__(item)
# Determine if the returned method is a partial and make sure the returned partial has
# not been created by Machine.__getattr__.
# https://github.com/tyarkoni/transitions/issues/214
def _add_model_to_state(self, state, model):
super(LockedMachine, self)._add_model_to_state(state, model) # pylint: disable=protected-access
for prefix in self.state_cls.dynamic_methods:
callback = "{0}_{1}".format(prefix, self._get_qualified_state_name(state))
func = getattr(model, callback, None)
if isinstance(func, partial) and func.func != state.add_callback:
state.add_callback(prefix[3:], callback)
# this needs to be overridden by the HSM variant to resolve names correctly
@staticmethod
def _get_qualified_state_name(state):
return state.name
def _locked_method(self, func, *args, **kwargs):
if self._ident.current != get_ident():
with nested(*self.machine_context):
return func(*args, **kwargs)
else:
return func(*args, **kwargs)
transitions-0.8.10+3/transitions/extensions/asyncio.py 0000644 0002322 0002322 00000067472 14155650047 023503 0 ustar debalance debalance import itertools
import logging
import asyncio
import contextvars
import inspect
from collections import defaultdict, deque
from functools import partial, reduce
import copy
from ..core import State, Condition, Transition, EventData, listify
from ..core import Event, MachineError, Machine
from .nesting import HierarchicalMachine, NestedState, NestedEvent, NestedTransition, _resolve_order
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
class AsyncState(State):
"""A persistent representation of a state managed by a ``Machine``. Callback execution is done asynchronously.
Attributes:
name (str): State name which is also assigned to the model(s).
on_enter (list): Callbacks awaited when a state is entered.
on_exit (list): Callbacks awaited when a state is entered.
ignore_invalid_triggers (bool): Indicates if unhandled/invalid triggers should raise an exception.
"""
async def enter(self, event_data):
""" Triggered when a state is entered. """
_LOGGER.debug("%sEntering state %s. Processing callbacks...", event_data.machine.name, self.name)
await event_data.machine.callbacks(self.on_enter, event_data)
_LOGGER.info("%sFinished processing state %s enter callbacks.", event_data.machine.name, self.name)
async def exit(self, event_data):
""" Triggered when a state is exited. """
_LOGGER.debug("%sExiting state %s. Processing callbacks...", event_data.machine.name, self.name)
await event_data.machine.callbacks(self.on_exit, event_data)
_LOGGER.info("%sFinished processing state %s exit callbacks.", event_data.machine.name, self.name)
class NestedAsyncState(NestedState, AsyncState):
async def scoped_enter(self, event_data, scope=[]):
self._scope = scope
await self.enter(event_data)
self._scope = []
async def scoped_exit(self, event_data, scope=[]):
self._scope = scope
await self.exit(event_data)
self._scope = []
class AsyncCondition(Condition):
""" A helper class to await condition checks in the intended way.
Attributes:
func (callable): The function to call for the condition check
target (bool): Indicates the target state--i.e., when True,
the condition-checking callback should return True to pass,
and when False, the callback should return False to pass.
"""
async def check(self, event_data):
""" Check whether the condition passes.
Args:
event_data (EventData): An EventData instance to pass to the
condition (if event sending is enabled) or to extract arguments
from (if event sending is disabled). Also contains the data
model attached to the current machine which is used to invoke
the condition.
"""
func = event_data.machine.resolve_callable(self.func, event_data)
res = func(event_data) if event_data.machine.send_event else func(*event_data.args, **event_data.kwargs)
if inspect.isawaitable(res):
return await res == self.target
return res == self.target
class AsyncTransition(Transition):
""" Representation of an asynchronous transition managed by a ``AsyncMachine`` instance.
Attributes:
source (str): Source state of the transition.
dest (str): Destination state of the transition.
prepare (list): Callbacks executed before conditions checks.
conditions (list): Callbacks evaluated to determine if
the transition should be executed.
before (list): Callbacks executed before the transition is executed
but only if condition checks have been successful.
after (list): Callbacks executed after the transition is executed
but only if condition checks have been successful.
"""
condition_cls = AsyncCondition
async def _eval_conditions(self, event_data):
res = await event_data.machine.await_all([partial(cond.check, event_data) for cond in self.conditions])
if not all(res):
_LOGGER.debug("%sTransition condition failed: Transition halted.", event_data.machine.name)
return False
return True
async def execute(self, event_data):
""" Executes the transition.
Args:
event_data: An instance of class EventData.
Returns: boolean indicating whether or not the transition was
successfully executed (True if successful, False if not).
"""
_LOGGER.debug("%sInitiating transition from state %s to state %s...",
event_data.machine.name, self.source, self.dest)
await event_data.machine.callbacks(self.prepare, event_data)
_LOGGER.debug("%sExecuted callbacks before conditions.", event_data.machine.name)
if not await self._eval_conditions(event_data):
return False
machine = event_data.machine
# cancel running tasks since the transition will happen
await machine.switch_model_context(event_data.model)
await event_data.machine.callbacks(event_data.machine.before_state_change, event_data)
await event_data.machine.callbacks(self.before, event_data)
_LOGGER.debug("%sExecuted callback before transition.", event_data.machine.name)
if self.dest: # if self.dest is None this is an internal transition with no actual state change
await self._change_state(event_data)
await event_data.machine.callbacks(self.after, event_data)
await event_data.machine.callbacks(event_data.machine.after_state_change, event_data)
_LOGGER.debug("%sExecuted callback after transition.", event_data.machine.name)
return True
async def _change_state(self, event_data):
if hasattr(event_data.machine, "model_graphs"):
graph = event_data.machine.model_graphs[id(event_data.model)]
graph.reset_styling()
graph.set_previous_transition(self.source, self.dest)
await event_data.machine.get_state(self.source).exit(event_data)
event_data.machine.set_state(self.dest, event_data.model)
event_data.update(getattr(event_data.model, event_data.machine.model_attribute))
await event_data.machine.get_state(self.dest).enter(event_data)
class NestedAsyncTransition(AsyncTransition, NestedTransition):
async def _change_state(self, event_data):
if hasattr(event_data.machine, "model_graphs"):
graph = event_data.machine.model_graphs[id(event_data.model)]
graph.reset_styling()
graph.set_previous_transition(self.source, self.dest)
state_tree, exit_partials, enter_partials = self._resolve_transition(event_data)
for func in exit_partials:
await func()
self._update_model(event_data, state_tree)
for func in enter_partials:
await func()
class AsyncEvent(Event):
""" A collection of transitions assigned to the same trigger """
async def trigger(self, _model, *args, **kwargs):
""" Serially execute all transitions that match the current state,
halting as soon as one successfully completes. Note that `AsyncEvent` triggers must be awaited.
Args:
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
func = partial(self._trigger, _model, *args, **kwargs)
return await self.machine.process_context(func, _model)
async def _trigger(self, model, *args, **kwargs):
state = self.machine.get_state(getattr(model, self.machine.model_attribute))
if state.name not in self.transitions:
msg = "%sCan't trigger event %s from state %s!" % (self.machine.name, self.name,
state.name)
ignore = state.ignore_invalid_triggers if state.ignore_invalid_triggers is not None \
else self.machine.ignore_invalid_triggers
if ignore:
_LOGGER.warning(msg)
return False
else:
raise MachineError(msg)
event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs)
return await self._process(event_data)
async def _process(self, event_data):
await self.machine.callbacks(self.machine.prepare_event, event_data)
_LOGGER.debug("%sExecuted machine preparation callbacks before conditions.", self.machine.name)
try:
for trans in self.transitions[event_data.state.name]:
event_data.transition = trans
if await trans.execute(event_data):
event_data.result = True
break
except Exception as err:
event_data.error = err
if self.machine.on_exception:
await self.machine.callbacks(self.machine.on_exception, event_data)
else:
raise
finally:
await self.machine.callbacks(self.machine.finalize_event, event_data)
_LOGGER.debug("%sExecuted machine finalize callbacks", self.machine.name)
return event_data.result
class NestedAsyncEvent(NestedEvent):
async def trigger(self, _model, _machine, *args, **kwargs):
""" Serially execute all transitions that match the current state,
halting as soon as one successfully completes. NOTE: This should only
be called by HierarchicalMachine instances.
Args:
_model (object): model object to
_machine (HierarchicalMachine): Since NestedEvents can be used in multiple machine instances, this one
will be used to determine the current state separator.
args and kwargs: Optional positional or named arguments that will
be passed onto the EventData object, enabling arbitrary state
information to be passed on to downstream triggered functions.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
func = partial(self._trigger, _model, _machine, *args, **kwargs)
return await _machine.process_context(func, _model)
async def _trigger(self, _model, _machine, *args, **kwargs):
state_tree = _machine._build_state_tree(getattr(_model, _machine.model_attribute), _machine.state_cls.separator)
state_tree = reduce(dict.get, _machine.get_global_name(join=False), state_tree)
ordered_states = _resolve_order(state_tree)
done = set()
res = None
for state_path in ordered_states:
state_name = _machine.state_cls.separator.join(state_path)
if state_name not in done and state_name in self.transitions:
state = _machine.get_state(state_name)
event_data = EventData(state, self, _machine, _model, args=args, kwargs=kwargs)
event_data.source_name = state_name
event_data.source_path = copy.copy(state_path)
res = await self._process(event_data)
if res:
elems = state_path
while elems:
done.add(_machine.state_cls.separator.join(elems))
elems.pop()
return res
async def _process(self, event_data):
machine = event_data.machine
await machine.callbacks(event_data.machine.prepare_event, event_data)
_LOGGER.debug("%sExecuted machine preparation callbacks before conditions.", machine.name)
try:
for trans in self.transitions[event_data.source_name]:
event_data.transition = trans
if await trans.execute(event_data):
event_data.result = True
break
except Exception as err:
event_data.error = err
if self.machine.on_exception:
await self.machine.callbacks(self.machine.on_exception, event_data)
else:
raise
finally:
await machine.callbacks(machine.finalize_event, event_data)
_LOGGER.debug("%sExecuted machine finalize callbacks", machine.name)
return event_data.result
class AsyncMachine(Machine):
""" Machine manages states, transitions and models. In case it is initialized without a specific model
(or specifically no model), it will also act as a model itself. Machine takes also care of decorating
models with conveniences functions related to added transitions and states during runtime.
Attributes:
states (OrderedDict): Collection of all registered states.
events (dict): Collection of transitions ordered by trigger/event.
models (list): List of models attached to the machine.
initial (str): Name of the initial state for new models.
prepare_event (list): Callbacks executed when an event is triggered.
before_state_change (list): Callbacks executed after condition checks but before transition is conducted.
Callbacks will be executed BEFORE the custom callbacks assigned to the transition.
after_state_change (list): Callbacks executed after the transition has been conducted.
Callbacks will be executed AFTER the custom callbacks assigned to the transition.
finalize_event (list): Callbacks will be executed after all transitions callbacks have been executed.
Callbacks mentioned here will also be called if a transition or condition check raised an error.
on_exception: A callable called when an event raises an exception. If not set,
the Exception will be raised instead.
queued (bool): Whether transitions in callbacks should be executed immediately (False) or sequentially.
send_event (bool): When True, any arguments passed to trigger methods will be wrapped in an EventData
object, allowing indirect and encapsulated access to data. When False, all positional and keyword
arguments will be passed directly to all callback methods.
auto_transitions (bool): When True (default), every state will automatically have an associated
to_{state}() convenience trigger in the base model.
ignore_invalid_triggers (bool): When True, any calls to trigger methods that are not valid for the
present state (e.g., calling an a_to_b() trigger when the current state is c) will be silently
ignored rather than raising an invalid transition exception.
name (str): Name of the ``Machine`` instance mainly used for easier log message distinction.
"""
state_cls = AsyncState
transition_cls = AsyncTransition
event_cls = AsyncEvent
async_tasks = {}
protected_tasks = []
current_context = contextvars.ContextVar('current_context', default=None)
def __init__(self, *args, **kwargs):
self._transition_queue_dict = {}
super().__init__(*args, **kwargs)
if self.has_queue is True:
self._transition_queue_dict = _DictionaryMock()
# _DictionaryMock sets and returns ONE internal value and ignores the passed key
self._transition_queue_dict[0] = self._transition_queue
def add_model(self, model, initial=None):
super().add_model(model, initial)
if self.has_queue == 'model':
for mod in listify(model):
self._transition_queue_dict[id(self) if mod is self.self_literal else id(mod)] = deque()
async def dispatch(self, trigger, *args, **kwargs): # ToDo: not tested
""" Trigger an event on all models assigned to the machine.
Args:
trigger (str): Event name
*args (list): List of arguments passed to the event trigger
**kwargs (dict): Dictionary of keyword arguments passed to the event trigger
Returns:
bool The truth value of all triggers combined with AND
"""
results = await self.await_all([partial(getattr(model, trigger), *args, **kwargs) for model in self.models])
return all(results)
async def callbacks(self, funcs, event_data):
""" Triggers a list of callbacks """
await self.await_all([partial(event_data.machine.callback, func, event_data) for func in funcs])
async def callback(self, func, event_data):
""" Trigger a callback function with passed event_data parameters. In case func is a string,
the callable will be resolved from the passed model in event_data. This function is not intended to
be called directly but through state and transition callback definitions.
Args:
func (string, callable): The callback function.
1. First, if the func is callable, just call it
2. Second, we try to import string assuming it is a path to a func
3. Fallback to a model attribute
event_data (EventData): An EventData instance to pass to the
callback (if event sending is enabled) or to extract arguments
from (if event sending is disabled).
"""
func = self.resolve_callable(func, event_data)
res = func(event_data) if self.send_event else func(*event_data.args, **event_data.kwargs)
if inspect.isawaitable(res):
await res
@staticmethod
async def await_all(callables):
"""
Executes callables without parameters in parallel and collects their results.
Args:
partials (list): A list of callable functions
Returns:
list: A list of results. Using asyncio the list will be in the same order as the passed callables.
"""
return await asyncio.gather(*[func() for func in callables])
async def switch_model_context(self, model):
"""
This method is called by an `AsyncTransition` when all conditional tests have passed and the transition will happen.
This requires already running tasks to be cancelled.
Args:
model (object): The currently processed model
"""
for running_task in self.async_tasks.get(id(model), []):
if self.current_context.get() == running_task or running_task in self.protected_tasks:
continue
elif running_task.done() is False:
_LOGGER.debug("Cancel running tasks...")
running_task.cancel()
async def process_context(self, func, model):
"""
This function is called by an `AsyncEvent` to make callbacks processed in Event._trigger cancellable.
Using asyncio this will result in a try-catch block catching CancelledEvents.
Args:
func (callable): The partial of Event._trigger with all parameters already assigned
model (object): The currently processed model
Returns:
bool: returns the success state of the triggered event
"""
if self.current_context.get() is None:
self.current_context.set(asyncio.current_task())
if id(model) in self.async_tasks:
self.async_tasks[id(model)].append(asyncio.current_task())
else:
self.async_tasks[id(model)] = [asyncio.current_task()]
try:
res = await self._process(func, model)
except asyncio.CancelledError:
res = False
finally:
self.async_tasks[id(model)].remove(asyncio.current_task())
if len(self.async_tasks[id(model)]) == 0:
del self.async_tasks[id(model)]
else:
res = await self._process(func, model)
return res
def remove_model(self, model):
""" Remove a model from the state machine. The model will still contain all previously added triggers
and callbacks, but will not receive updates when states or transitions are added to the Machine.
If an event queue is used, all queued events of that model will be removed."""
models = listify(model)
if self.has_queue == 'model':
for mod in models:
del self._transition_queue_dict[id(mod)]
self.models.remove(mod)
else:
for mod in models:
self.models.remove(mod)
if len(self._transition_queue) > 0:
queue = self._transition_queue
new_queue = [queue.popleft()] + [e for e in queue if e.args[0] not in models]
self._transition_queue.clear()
self._transition_queue.extend(new_queue)
async def _process(self, trigger, model):
# default processing
if not self.has_queue:
if not self._transition_queue:
# if trigger raises an Error, it has to be handled by the Machine.process caller
return await trigger()
else:
raise MachineError("Attempt to process events synchronously while transition queue is not empty!")
self._transition_queue_dict[id(model)].append(trigger)
# another entry in the queue implies a running transition; skip immediate execution
if len(self._transition_queue_dict[id(model)]) > 1:
return True
while self._transition_queue_dict[id(model)]:
try:
await self._transition_queue_dict[id(model)][0]()
except Exception:
# if a transition raises an exception, clear queue and delegate exception handling
self._transition_queue_dict[id(model)].clear()
raise
try:
self._transition_queue_dict[id(model)].popleft()
except KeyError:
return True
return True
class HierarchicalAsyncMachine(HierarchicalMachine, AsyncMachine):
state_cls = NestedAsyncState
transition_cls = NestedAsyncTransition
event_cls = NestedAsyncEvent
async def trigger_event(self, _model, _trigger, *args, **kwargs):
""" Processes events recursively and forwards arguments if suitable events are found.
This function is usually bound to models with model and trigger arguments already
resolved as a partial. Execution will halt when a nested transition has been executed
successfully.
Args:
_model (object): targeted model
_trigger (str): event name
*args: positional parameters passed to the event and its callbacks
**kwargs: keyword arguments passed to the event and its callbacks
Returns:
bool: whether a transition has been executed successfully
Raises:
MachineError: When no suitable transition could be found and ignore_invalid_trigger
is not True. Note that a transition which is not executed due to conditions
is still considered valid.
"""
with self():
res = await self._trigger_event(_model, _trigger, None, *args, **kwargs)
return self._check_event_result(res, _model, _trigger)
async def _trigger_event(self, _model, _trigger, _state_tree, *args, **kwargs):
if _state_tree is None:
_state_tree = self._build_state_tree(listify(getattr(_model, self.model_attribute)),
self.state_cls.separator)
res = {}
for key, value in _state_tree.items():
if value:
with self(key):
tmp = await self._trigger_event(_model, _trigger, value, *args, **kwargs)
if tmp is not None:
res[key] = tmp
if not res.get(key, None) and _trigger in self.events:
tmp = await self.events[_trigger].trigger(_model, self, *args, **kwargs)
if tmp is not None:
res[key] = tmp
return None if not res or all([v is None for v in res.values()]) else any(res.values())
class AsyncTimeout(AsyncState):
"""
Adds timeout functionality to an asynchronous state. Timeouts are handled model-specific.
Attributes:
timeout (float): Seconds after which a timeout function should be
called.
on_timeout (list): Functions to call when a timeout is triggered.
runner (dict): Keeps track of running timeout tasks to cancel when a state is exited.
"""
dynamic_methods = ["on_timeout"]
def __init__(self, *args, **kwargs):
"""
Args:
**kwargs: If kwargs contain 'timeout', assign the float value to
self.timeout. If timeout is set, 'on_timeout' needs to be
passed with kwargs as well or an AttributeError will be thrown
if timeout is not passed or equal 0.
"""
self.timeout = kwargs.pop("timeout", 0)
self._on_timeout = None
if self.timeout > 0:
try:
self.on_timeout = kwargs.pop("on_timeout")
except KeyError:
raise AttributeError("Timeout state requires 'on_timeout' when timeout is set.")
else:
self._on_timeout = kwargs.pop("on_timeout", [])
self.runner = {}
super().__init__(*args, **kwargs)
async def enter(self, event_data):
"""
Extends `transitions.core.State.enter` by starting a timeout timer for
the current model when the state is entered and self.timeout is larger
than 0.
Args:
event_data (EventData): events representing the currently processed event.
"""
if self.timeout > 0:
self.runner[id(event_data.model)] = self.create_timer(event_data)
await super().enter(event_data)
async def exit(self, event_data):
"""
Cancels running timeout tasks stored in `self.runner` first (when not note) before calling further exit callbacks.
Args:
event_data (EventData): Data representing the currently processed event.
Returns:
"""
timer_task = self.runner.get(id(event_data.model), None)
if timer_task is not None and not timer_task.done():
timer_task.cancel()
await super().exit(event_data)
def create_timer(self, event_data):
"""
Creates and returns a running timer. Shields self._process_timeout to prevent cancellation when
transitioning away from the current state (which cancels the timer) while processing timeout callbacks.
Args:
event_data (EventData): Data representing the currently processed event.
Returns (cancellable): A running timer with a cancel method
"""
async def _timeout():
try:
await asyncio.sleep(self.timeout)
await asyncio.shield(self._process_timeout(event_data))
except asyncio.CancelledError:
pass
return asyncio.ensure_future(_timeout())
async def _process_timeout(self, event_data):
_LOGGER.debug("%sTimeout state %s. Processing callbacks...", event_data.machine.name, self.name)
await event_data.machine.callbacks(self.on_timeout, event_data)
_LOGGER.info("%sTimeout state %s processed.", event_data.machine.name, self.name)
@property
def on_timeout(self):
"""
List of strings and callables to be called when the state timeouts.
"""
return self._on_timeout
@on_timeout.setter
def on_timeout(self, value):
""" Listifies passed values and assigns them to on_timeout."""
self._on_timeout = listify(value)
class _DictionaryMock(dict):
def __setitem__(self, key, item):
self._value = item
def __getitem__(self, key):
return self._value
def __repr__(self):
return repr("{{'*': {0}}}".format(self._value))
transitions-0.8.10+3/transitions/extensions/diagrams_graphviz.py 0000644 0002322 0002322 00000024550 14155650047 025525 0 ustar debalance debalance """
transitions.extensions.diagrams
-------------------------------
Graphviz support for (nested) machines. This also includes partial views
of currently valid transitions.
"""
import logging
from functools import partial
from collections import defaultdict
from os.path import splitext
import copy
from .diagrams import BaseGraph
from ..core import listify
try:
import graphviz as pgv
except ImportError: # pragma: no cover
pgv = None
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# this is a workaround for dill issues when partials and super is used in conjunction
# without it, Python 3.0 - 3.3 will not support pickling
# https://github.com/pytransitions/transitions/issues/236
_super = super
class Graph(BaseGraph):
""" Graph creation for transitions.core.Machine.
Attributes:
machine (object): Reference to the related machine.
"""
def __init__(self, machine, title=None):
self.reset_styling()
_super(Graph, self).__init__(machine, title)
def set_previous_transition(self, src, dst, key=None):
self.custom_styles['edge'][src][dst] = 'previous'
self.set_node_style(src, 'previous')
def set_node_style(self, state, style):
self.custom_styles['node'][state] = style
def reset_styling(self):
self.custom_styles = {'edge': defaultdict(lambda: defaultdict(str)),
'node': defaultdict(str)}
def _add_nodes(self, states, container):
for state in states:
style = self.custom_styles['node'][state['name']]
container.node(state['name'], label=self._convert_state_attributes(state),
**self.machine.style_attributes['node'][style])
def _add_edges(self, transitions, container):
edge_labels = defaultdict(lambda: defaultdict(list))
for transition in transitions:
try:
dst = transition['dest']
except KeyError:
dst = transition['source']
edge_labels[transition['source']][dst].append(self._transition_label(transition))
for src, dests in edge_labels.items():
for dst, labels in dests.items():
style = self.custom_styles['edge'][src][dst]
container.edge(src, dst, label=' | '.join(labels), **self.machine.style_attributes['edge'][style])
def generate(self, title=None, roi_state=None):
""" Generate a DOT graph with graphviz
Args:
roi_state (str): Optional, show only custom states and edges from roi_state
"""
if not pgv: # pragma: no cover
raise Exception('AGraph diagram requires graphviz')
title = self.machine.title if not title else title
fsm_graph = pgv.Digraph(name=title, node_attr=self.machine.style_attributes['node']['default'],
edge_attr=self.machine.style_attributes['edge']['default'],
graph_attr=self.machine.style_attributes['graph']['default'])
fsm_graph.graph_attr.update(**self.machine.machine_attributes)
fsm_graph.graph_attr['label'] = title
# For each state, draw a circle
states, transitions = self._get_elements()
if roi_state:
transitions = [t for t in transitions
if t['source'] == roi_state or self.custom_styles['edge'][t['source']][t['dest']]]
state_names = [t for trans in transitions
for t in [trans['source'], trans.get('dest', trans['source'])]]
state_names += [k for k, style in self.custom_styles['node'].items() if style]
states = _filter_states(states, state_names, self.machine.state_cls)
self._add_nodes(states, fsm_graph)
self._add_edges(transitions, fsm_graph)
setattr(fsm_graph, 'draw', partial(self.draw, fsm_graph))
return fsm_graph
def get_graph(self, title=None):
return self.generate(title, roi_state=self.roi_state)
@staticmethod
def draw(graph, filename, format=None, prog='dot', args=''):
"""
Generates and saves an image of the state machine using graphviz. Note that `prog` and `args` are only part
of the signature to mimic `Agraph.draw` and thus allow to easily switch between graph backends.
Args:
filename (str or file descriptor or stream or None): path and name of image output, file descriptor, stream object or None
format (str): Optional format of the output file
prog (str): ignored
args (list): ignored
Returns:
None or str: Returns a binary string of the graph when the first parameter (`filename`) is set to None.
"""
graph.engine = prog
if filename is None:
if format is None:
raise ValueError("Parameter 'format' must not be None when filename is no valid file path.")
return graph.pipe(format)
try:
filename, ext = splitext(filename)
format = format if format is not None else ext[1:]
graph.render(filename, format=format if format else 'png', cleanup=True)
except (TypeError, AttributeError):
if format is None:
raise ValueError("Parameter 'format' must not be None when filename is no valid file path.")
filename.write(graph.pipe(format))
class NestedGraph(Graph):
""" Graph creation support for transitions.extensions.nested.HierarchicalGraphMachine. """
def __init__(self, *args, **kwargs):
self._cluster_states = []
_super(NestedGraph, self).__init__(*args, **kwargs)
def set_previous_transition(self, src, dst, key=None):
src_name = self._get_global_name(src.split(self.machine.state_cls.separator))
dst_name = self._get_global_name(dst.split(self.machine.state_cls.separator))
_super(NestedGraph, self).set_previous_transition(src_name, dst_name, key)
def _add_nodes(self, states, container, prefix='', default_style='default'):
for state in states:
name = prefix + state['name']
label = self._convert_state_attributes(state)
if state.get('children', []):
cluster_name = "cluster_" + name
style_name = self.custom_styles['node'][name] or default_style
attr = {'label': label, 'rank': 'source'}
attr.update(**self.machine.style_attributes['graph'][style_name])
with container.subgraph(name=cluster_name, graph_attr=attr) as sub:
self._cluster_states.append(name)
is_parallel = isinstance(state.get('initial', ''), list)
width = '0.0' if is_parallel else '0.1'
with sub.subgraph(name=cluster_name + '_root',
graph_attr={'label': '', 'color': 'None', 'rank': 'min'}) as root:
root.node(name + "_anchor", shape='point', fillcolor='black', width=width)
self._add_nodes(state['children'], sub, default_style='parallel' if is_parallel else 'default',
prefix=prefix + state['name'] + self.machine.state_cls.separator)
else:
style = self.machine.style_attributes['node'][default_style].copy()
style.update(self.machine.style_attributes['node'][self.custom_styles['node'][name] or default_style])
container.node(name, label=label, **style)
def _add_edges(self, transitions, container, prefix=''):
edges_attr = defaultdict(lambda: defaultdict(dict))
for transition in transitions:
# enable customizable labels
src = prefix + transition['source']
try:
dst = prefix + transition['dest']
except KeyError:
dst = src
if edges_attr[src][dst]:
attr = edges_attr[src][dst]
attr[attr['label_pos']] = ' | '.join([edges_attr[src][dst][attr['label_pos']],
self._transition_label(transition)])
else:
edges_attr[src][dst] = self._create_edge_attr(src, dst, transition)
for custom_src, dests in self.custom_styles['edge'].items():
for custom_dst, style in dests.items():
if style and (custom_src not in edges_attr or custom_dst not in edges_attr[custom_src]):
edges_attr[custom_src][custom_dst] = self._create_edge_attr(custom_src, custom_dst,
{'trigger': '', 'dest': ''})
for src, dests in edges_attr.items():
for dst, attr in dests.items():
del attr['label_pos']
style = self.custom_styles['edge'][src][dst]
attr.update(**self.machine.style_attributes['edge'][style])
container.edge(attr.pop('source'), attr.pop('dest'), **attr)
def _create_edge_attr(self, src, dst, transition):
label_pos = 'label'
attr = {}
if src in self._cluster_states:
attr['ltail'] = 'cluster_' + src
src_name = src + "_anchor"
label_pos = 'headlabel'
else:
src_name = src
if dst in self._cluster_states:
if not src.startswith(dst):
attr['lhead'] = "cluster_" + dst
label_pos = 'taillabel' if label_pos.startswith('l') else 'label'
dst_name = dst + '_anchor'
else:
dst_name = dst
# remove ltail when dst (ltail always starts with 'cluster_') is a child of src
if 'ltail' in attr and dst_name.startswith(attr['ltail'][8:]):
del attr['ltail']
attr[label_pos] = self._transition_label(transition)
attr['label_pos'] = label_pos
attr['source'] = src_name
attr['dest'] = dst_name
return attr
def _filter_states(states, state_names, state_cls, prefix=None):
prefix = prefix or []
result = []
for state in states:
pref = prefix + [state['name']]
if 'children' in state:
state['children'] = _filter_states(state['children'], state_names, state_cls, prefix=pref)
result.append(state)
elif getattr(state_cls, 'separator', '_').join(pref) in state_names:
result.append(state)
return result
transitions-0.8.10+3/setup.py 0000644 0002322 0002322 00000004212 14155650047 016401 0 ustar debalance debalance import codecs
import sys
from setuptools import setup, find_packages
with open('transitions/version.py') as f:
exec(f.read())
with codecs.open('README.md', 'r', 'utf-8') as f:
import re
# cut the badges from the description and also the TOC which is currently not working on PyPi
regex = r"([\s\S]*)## Quickstart"
readme = f.read()
long_description = re.sub(regex, "## Quickstart", readme, 1)
assert long_description[:13] == '## Quickstart' # Description should start with a headline (## Quickstart)
tests_require = ['mock', 'tox', 'graphviz', 'pygraphviz']
extras_require = {'diagrams': ['pygraphviz']}
extra_setuptools_args = {}
if 'setuptools' in sys.modules:
extras_require['test'] = ['pytest']
tests_require.append('pytest')
setup(
name="transitions",
version=__version__,
description="A lightweight, object-oriented Python state machine implementation with many extensions.",
long_description=long_description,
long_description_content_type="text/markdown",
author='Tal Yarkoni',
author_email='tyarkoni@gmail.com',
maintainer='Alexander Neumann',
maintainer_email='aleneum@gmail.com',
url='http://github.com/pytransitions/transitions',
packages=find_packages(exclude=['tests', 'test_*']),
package_data={'transitions': ['data/*'],
'transitions.tests': ['data/*']
},
include_package_data=True,
install_requires=['six'],
extras_require=extras_require,
tests_require=tests_require,
license='MIT',
download_url='https://github.com/pytransitions/transitions/archive/%s.tar.gz' % __version__,
classifiers=[
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 2',
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3',
'Programming Language :: Python :: 3.3',
'Programming Language :: Python :: 3.4',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
'Programming Language :: Python :: 3.7',
'Programming Language :: Python :: 3.8',
],
**extra_setuptools_args
)
transitions-0.8.10+3/conftest.py 0000644 0002322 0002322 00000000502 14155650047 017064 0 ustar debalance debalance from os.path import basename
try:
import asyncio
import contextvars
with_async = True
except ImportError:
with_async = False
async_files = ['test_async.py', 'asyncio.py']
def pytest_ignore_collect(path):
if not with_async and basename(str(path)) in async_files:
return True
return False
transitions-0.8.10+3/examples/ 0000755 0002322 0002322 00000000000 14155650047 016506 5 ustar debalance debalance transitions-0.8.10+3/examples/Graph MIxin Demo.ipynb 0000644 0002322 0002322 00002712274 14155650047 022503 0 ustar debalance debalance {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Table of Content \n",
"\n",
"- [The Matter graph](#The-Matter-graph)\n",
"- [Hide auto transitions](#Hide-auto-transitions)\n",
"- [Previous state and transition notation](#Previous-state-and-transition-notation)\n",
"- [One Machine and multiple models](#One-Machine-and-multiple-models)\n",
"- [Show only the current region of interest](#Show-only-the-current-region-of-interest)\n",
"- [Example graph from Readme.md](#Example-graph-from-Readme.md)\n",
"- [Custom styling](#Custom-styling)\n",
"- [Enum states](#Enum-states)"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"hide_input": false
},
"outputs": [],
"source": [
"import os, sys, inspect, io\n",
"\n",
"cmd_folder = os.path.realpath(\n",
" os.path.dirname(\n",
" os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0])))\n",
"\n",
"if cmd_folder not in sys.path:\n",
" sys.path.insert(0, cmd_folder)\n",
" \n",
"from transitions import *\n",
"from transitions.extensions import GraphMachine\n",
"from IPython.display import Image, display, display_png\n",
"\n",
"\n",
"class Model():\n",
" \n",
" # graph object is created by the machine\n",
" def show_graph(self, **kwargs):\n",
" stream = io.BytesIO()\n",
" self.get_graph(**kwargs).draw(stream, prog='dot', format='png')\n",
" display(Image(stream.getvalue()))\n",
"\n",
" \n",
"class Matter(Model):\n",
" def alert(self):\n",
" pass\n",
" \n",
" def resume(self):\n",
" pass\n",
" \n",
" def notify(self):\n",
" pass\n",
" \n",
" def is_valid(self):\n",
" return True\n",
" \n",
" def is_not_valid(self):\n",
" return False\n",
" \n",
" def is_also_valid(self):\n",
" return True\n",
"\n",
"\n",
"extra_args = dict(initial='solid', title='Matter is Fun!',\n",
" show_conditions=True, show_state_attributes=True)"
]
},
{
"cell_type": "markdown",
"metadata": {
"hide_input": true
},
"source": [
"### The Matter graph"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"hide_input": true
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"transitions = [\n",
" { 'trigger': 'melt', 'source': 'solid', 'dest': 'liquid' },\n",
" { 'trigger': 'evaporate', 'source': 'liquid', 'dest': 'gas', 'conditions':'is_valid' },\n",
" { 'trigger': 'sublimate', 'source': 'solid', 'dest': 'gas', 'unless':'is_not_valid' },\n",
" { 'trigger': 'ionize', 'source': 'gas', 'dest': 'plasma', \n",
" 'conditions':['is_valid','is_also_valid'] }\n",
"]\n",
"states=['solid', 'liquid', {'name': 'gas', 'on_exit': ['resume', 'notify']},\n",
" {'name': 'plasma', 'on_enter': 'alert', 'on_exit': 'resume'}]\n",
"\n",
"model = Matter()\n",
"machine = GraphMachine(model=model, states=states, transitions=transitions, \n",
" show_auto_transitions=True, **extra_args)\n",
"model.show_graph()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Hide auto transitions"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"hide_input": false
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"machine.auto_transitions_markup = False # hide auto transitions\n",
"model.show_graph(force_new=True) # rerender graph"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Previous state and transition notation"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"hide_input": false
},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAABN0AAACyCAIAAAD53S5AAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeVhM+xsA8Hfapn2PNrTQogiDpCKqqyjSle3Wvda4iCxXsnatUVGuncu1E9cSxSUSWpDftaUFKVGpVNM603Z+fxz3GFNN0zpTvZ/H45m+c86Z95yZmnnnfM/70giCAIQQQgghhBBCSEBEBB0AQgghhBBCCKEuDfNShBBCCCGEEEKChHkpQgghhBBCCCFBEhN0AAgJWkEBJCZCYSGw2YIOhQ9yctC9O/TtC3S6oENBCCGEEEKodWBeirqqxEQ4ehSuX4fUVEGH0nRiYmBpCRMnws8/g5KSoKNBCCGEEEKoRXAeL+p63r6FCRPA1BTCwsDFBW7cgI8fgcUCgugA/4qLISkJjh+Hnj1h3TrQ1gY/PygvF/QxRQghhBBCqPlo2CcGdSEsFvz+O+zaBX36wI4d4OAANJqgY2qBkhI4cAA2bwZFRQgOhokTBR0QQgghhBBCzYF5KeoycnPBxQWSkmDTJpg/H8Q6yyT2z5/B1xf++gtWrYItWzp2po0QQgghhLokzEtR15CYCE5OICYG166BkZGgo2kDx4+Dpyc4O8PJkyAlJehoEEIIIYQQagLMS1EXkJkJ5uagrw9XroCKSoOLffwIYWFw5w7x7/9oeXlQWtaOITZARATk5QldXdqQITBmDDg68so5HzwAFxcYNQpCQ0EELx1HCCGEEEIdBualqLMrLwcbGygthdhYUFSsf5kXL2DdWggPJyQkKg16VffoXqsoVysp0b6B1oNGELQylmheoURGtljaR5CTg/nzwdcXFBTqX+HhQ7Czg+XLYcuW9o0UIYQQQgih5sO8FHV206fDnTvw6BHo6NRzb0EBrFsHBw9U99IsGz2ksr8BISba3hHyR6S4TDLuuUxUAk1CEvz9YebM+k+KHj8OM2fCxYvg6truMSKEEEIIIdQcmJeiTu3ePRg1CsLDYezYeu6Ni4MJE2qrK0udR7DM+0FHKBhEK2fJhj+Quv8/sLGBixfrPwM8axbcuQNJSSAt3e4BIoQQQggh1GSYl6LOq6YGBg2CXr0gLKyee8+ehZkzKw17MWc4E5L0dg+uRcQycxQPXhJRVYOIG6Cvz313bi4YGIC3N/j5CSA4hBBCCCGEmgiLo6DO6+xZSEqCoKB67jp8GH76qdxqQJHnjx0uKQWA6h7qBb/9XF1ZDubm8O4d993dusGaNRAQAIWFgogOIYQQQgihpsHzpajzsrICTU0IDeUev3MHHBzKxliUjbMWRFithlZZpRR8RkxCGh495p7QW1ICWlqweTMsXiyg6BBCCCGEEOIXni9FnVRODsTFgYcH9/jbt/Djj+yBRmVjO3ZSCgCEhHjRvB9r8/Pgxx+htva7++TkwMUFLl0SUGgIIYQQQgg1AealqJO6dw9ERcHWlnt84YJqBeli97EdospRo2oVZIvmuUJ0NBw7xn3fmDEQGwtstiDiQgghhBBCqAkwL0Wd1IsXYGjIXZD26lW4HVkyyZYQFxNQWK2vuod6+UgGrFoFRUXf3TFoEFRVQXKygOJCCCGEEEKIX5iXok4qOxt69PhupKYGli1lDzGp6t1TQDG1lbKxVkQlC/z9vxvV1gYAyM4WSEgIIYQQQgjxD/NS1EmVl4OMzHcj4eHwPr20g9c6qhchLVk2ajAcPAgVFd9GZWUBAEpKBBUVQgghhBBCfMK8FHVSBAG07y8hPXOmyki3Rk1JQAG1LZaFGRQXw82b34bI3ceC2wghhBBCSOhhXoq6BoKAmzfZJnqCjqOt1MrLVOtpf5eXIoQQQggh1EFgXoq6hrQ0YDKr9LQFHUcbquypTjxNEHQUCCGEEEIINRnmpahreP8eADrrJF5STTdlWlqaoKNACCGEEEKoyTpPtwyEeCkuBoBaKTqPRfZFPvr90h0A0FCUe7bVq50Ca9iVhNfzjl4BAAkx0czdPo0uT0jToRirHCGEEEIIoY4Hz5eirqG6GgBAhNcLfoGd+ed9q020u3EOlrErh23Y774vtNUjanTLLoP7ft632tpQh88NEjQRqKlpneAQQgghhBBqR5iXIsQLQUAtQdS2QVXbttsyQgghhBBCHQvO40WIF1lJiccbF3SsLSOEEEIIIdSxYF6KEEIIIYQQQg1is9mJiYm5ubklJVjLo0F0Ol1JScnExERZWbkZq2NeilCDbjxPnXHwInn7Q8hKuvjX35c3OV82X4mKSc2oqqkx0lRbMdb64N3HD1LSAWD6cLOeKor+16IBYKi+9rXlPwPA3ddp0/acAwAlGankgKX8bLm6trZ/D/U1LjbtuLsIIYQQQuibwsLCEydOXL58OSYmpposVoL4YGBg4OzsPHPmTBMTE/7XwrwUoQY5mhl83rf6lwMXb75IpQbf5xWOCzguTRf/c67rYD2tjwXMtRciX3/K5ayau9TRUtc7gFpldF+9z/tW/+B/9MMXJv9b/vClyO/vO+n5he2yrwghhBBC6Kvy8vIdO3YEBASIioq6uLh4enoOGjRIS0tLTk5O0KEJLzabnZ+f//Lly6ioqEuXLgUFBY0fPz4oKKh37978rI51jxBqmq1X7zErWJvd7Eca68rQJQw11A7MmlBeWdXqWzbW7Bbys/NnZmnLt4wQQgghhPh0+fJlY2PjXbt2+fn5ffr06cSJE9OnTzcyMsKklDc6na6lpeXg4LB9+/bU1NSIiIi0tDRTU1NfX18Wi9Xo6piXItQ0d1+/A4BRffWoERVZ6T7dVdpiy+oKsvrdWmHLCLWuU6dO0f4jKysr6HDqERgYSIanra3N/1rnzp0j15KUlKQGV61aRe3ssGHD2iBYhBBCwoIgiNWrV//444+2trapqam//fYb5qLNQ6PRHB0d//3338DAwAMHDowePTo3N5f3KpiXItQEldU1paxKuriYDF2Cc1xBWrKhVVq4ZVU56RZuGaE2sn//foIgSku/ntIvLS3t06ePk5OTYKMirVixgiAIMzMzzsFGI5w6dSpBELa2tpyD/v7+BEEQBCEqKtpW4SKEEBICFRUVbm5uQUFBx44dO3r0aPfu3QUdUYcnJia2aNGiuLi4vLw8c3PzxMREHgtjXopQE0iIicpKSrCrqsvYlZzj+SXlXEuKiNAqq2s4R5gV7GZsuai8omUhI/SNrKyslZVVG22cIIja2tra2to22n7LCX+ECCGEBKW2ttbDwyMqKioyMvKXX34RdDidipGRUXx8vLa2tr29fWZmZkOLYV6KUNPYmugDwN3XadRIbnHZu9wvXIt1l5fNKSrhXOZTAbOpWy4oLX/7uaDlMSPUDuTk5N69excRESHoQBok/BEihBASlLVr14aFhV28eNHa2lrQsXRCKioqERERqqqq48ePp2ZaccG8FKGmWT3eRlFGat2F29FJ78vYlclZeUtOXOsmz32JnU1fvRxm6Z/3EsrYlel5hWsv3FKVk2nSllOz8xf8FcY1rRchhBBCCLWuS5cu+fv7Hz58eNSoUc1YvXlFDboaOTm5sLCwrKwsT0/PehfAvBShr/ZFPuq+YGvix9zsopLuC7ZuC4u+8Ty1+4KtZCuXnkt2LPgrDAB01JQifvtlQC+N2YcvmfiErDhzY7HDcF01Ja6trXIe+ZPlgJB/YvuuDF584voCu2Hd5GUKyyq6L9i6+UpUo1vuuzLY68S12TaDjTXVKqtrui/YuvRUeFP3KA/g94sXjx8/Hh0dnZ6ejn23eMvLy1u8eLGOjo6EhISampqrq+uzZ88AoKioiMZh8+bNAFBdXU2NTJo0iRw5f/68vb29urq6lJRUv379QkJCqCmjnO9YT548sbW1lZOTk5aWHjVqVExMDGcYX758WbZsmb6+voSEhJKSkqOjY1RUFHnXlStXqAdNSUmZPHmyiooK+WN+fj4/AZSVlcXExJCriImJNbrv/OOMjaq5x2az169fb2RkJC0trays7OzsHBYWVlNTw3tTrXLA+YwQAJKTk11cXBQUFGRkZKytrR8+fNikHUcIIdTRlZeXL126dMaMGc2evltvUQNUl46OzrFjx86ePXvv3r2699IIgmj3kBBqe5MnAwCEhn79MTQUpkzJ3be6jR5tUsiZR+8yqf6lAkF/mqTw52Xg+I1OpNHctLTef/lCfgoXExPT1tbu1auXDodevXr16NGDM0XpmrKzsy0sLFgs1tGjR0eMGJGRkbFw4cJHjx7dvXvXwsICABwdHW/dupWamqqvr0+tNXz4cC8vr2nTpgHA9evXnZ2dt27dOn/+/JqamrNnz3p7ey9btiwg4Fsn2wEDBrx9+7Z///5BQUH9+/dPSkqaPXt2cnLyrVu3Ro4cCQA5OTnDhw8vLy8/cuTIiBEjcnJyfH19L1++fOjQoTlz5pAbcXFxuXr16siRI/38/IYOHfry5UtLS8ucnJz4+PhGA5CVlR0wYABX6tXovtd16tQpDw+P/fv3z58/n3OcjK2iooKsZzt37twLFy5cuHDBysqquLg4MDAwMDAwKirKxsam0WektQ54fn7+x48fG4rw7du3Q4YMkZGROXbsmIWFxfv371esWJGampqdnV23or2YmNjgwYPj4+MbDb7VsdnsxMTE3NzckpKSxpfuquh0upKSkomJibKysqBjQQh1JBs2bNi1a1dKSoqGhkZLtlP3TQfVy9nZ+f3798+ePeP6/NnVP4yiDoQgYNYsUFcHXd2v/3r2BAmc5dowE4DXO3fC5MmFhYVpaWlpaWlZWVnZ2dlpaWnXr19PTU2lPuMqKSnpfU9DQ0NPT09KSkqwu9BufH19MzIyTp8+PXbsWAAwMTE5d+6cjo6Ol5dXQkICAKxYseLmzZs7d+7cu3cvuUpMTMynT5/c3NyojdjY2Pj6+pK3vby8Hj9+HBISsm7dOnl5eWqZsrKyffv2DRgwAAAGDx586tSp/v37L1myhDw/6evr+/79+7Nnz5I1Y+Xl5c+cOaOnp7d48WJnZ2fOwoA+Pj5kdmdubk6dCecngGbse7PduXPHxMTE3t4eAKSkpAICAsLCwvhct7UOOG+rV68uKio6cuQIGWS/fv2OHTump6fX6Irto7Cw8MSJE5cvX46JicH5DvwzMDBwdnaeOXOmiYmJoGNBCAm7wsLCwMBAPz+/FialiH87d+4kP2y4u7tzjmNeijoMGg0SE+HECRARAfITGo0G3bqBnh4YGHxLVnV1QVOzzgx1Gg0AgACgtXvc7YUGxNfdrENJSYnBYDAYDK5xMl+lktW0tLTIyMg3b94UFxdTK9bNV3V1daWlO1v3mitXroiIiHB2EFFXVzcxMXn69OnHjx+1tbVtbW0HDhz4119/bdy4UUVFBQACAgK8vb2pr/qcnJy4GpCYmZmdOnUqMTGR86yjjIwMmZSS+vXrp6mp+fz58+zsbA0NjcuXLwPAuHHjqAXodLqtre3Jkyf/+eefn3/+mRofOnQo1y7wGUAz9p3Hurw5ODjs37/f09Nz1qxZQ4YMERUVTUlJ4XPd1jrgvN28eRMAxowZQ41oamoaGBikpqbyuYU2Ul5evmPHjoCAAFFRURcXF09Pz0GDBmlpaWEbPR7YbHZ+fv7Lly+joqIuXboUFBQ0fvz4oKCg3r17Czo0hJDwOnHihKioKNf0H9Sm+vTp4+LicvDgQa68FK8vRR2JpSWIiQF12oAg4PNniIuDU6dg2zaYORNGjIAePUBSEvQi9jg+WP3gwX9rysoCAK2qqtVDupLwuvuCrQ9S0pt9FWhrobEqQaaR0kpcyHzV2dnZ09PT398/NDQ0ISGByWQWFBQkJCSEhYX5+/vb2dkBQGRk5G+//WZvb29qaiojI6OsrDx48ODJkyevWrXq0KFD165de/r0aXk5d7OcjoLNZjOZzNraWgUFBc4rG//3v/8BwJs3b8jFli9fXl5evm/fPgBITU29f/8+NbcWAJhM5vr16/v166ekpESu/ttvvwEA12FRVFTkevRu3boBQG5uLhmGpKQkV+5BnibNycnhHJSp81zzGUDz9r159u7de+LEibS0NFtbW3l5eQcHBzLx5lOrHHAe2Gx2SUmJpKSkrOx3dcvIZ0SALl++bGxsvGvXLj8/v0+fPp04cWL69OlGRkaYlPJGp9O1tLQcHBy2b9+empoaERGRlpZmamrq6+tbd1Y2QgiRLl++7OLiwuMPLP8VIrg0WgeBRxUGzpoIGRkZU6ZMkZOTU1FR8fDwKCwsTE9Pd3Z2lpOT09DQmDt3LuclHk0tviAo7u7usbGxnz9/5hzEvBR1JEOHQr1z2WpqgM0G6peuqgroItWrjS9/K/StoQEAIgXFrR6Sy+C+n/etpv7tch/X+DptQ6SohGilBtBNyldXrlw5fvz4wYMHN5SvlpWVtUpUbYdOpysqKoqJiVVVVRF1UKX5pkyZ0qNHjz179rDZ7KCgoLlz53K+jTk7O2/atGnu3Lmpqam1tbUEQezatQsAuK7h//LlC9dIbm4uAHTr1o1OpysoKLBYLK5rCMm/2urq6rz3gp8AaHXOqPO5781Do9E8PDwiIyOLioquXLlCEISrq+vOnTv5XL1VDjgPdDpdTk6OxWJxFawvKBBYcyaCIFavXv3jjz/a2tqmpqb+9ttvmIs2D41Gc3R0/PfffwMDAw8cODB69GjyFw0hhDixWKzY2FgHBwcey1A1jYqKipYsWbJ58+acnJz79+8XFBSMHj06Ojq6oRVv3rw5derU0aNHJyUlZWZmenp6Llu2zMfnWy2SRYsW7d69+48//vjy5UtSUpKRkdGECRMePHgAAC4uLgRBTJgwAQCWLVu2cuXKnJyc4ODgU6dO/fTTT97e3ps2bcrOzvbz8zty5MiGDRv4f1AhYWdnJyoqylX9CPNS1JEMHQq8v/GRkABJSdiwAZ7/sMJaNenbHcbGICYmnpnT8KodntjHXFobF4KrN18tKioqKCh49erV7du3681XZWVlhT9fdXV1ra6u5vric/v27T179qSu6xMTE1uyZElubm5QUNC5c+cWL15MLVlTUxMTE6Ourr548WI1NTUy/auoqKj7QCwW68mTJ9SPL1++zMrKMjMzIy9rmThxIgCEh387685ms+/cuSMlJcU517QuPgOQlpaurKwkbxsaGh46dIjPfW8eRUXF5ORkABAXF7e3tye//eXcO95a5YDz5ujoCP/N5iXl5+fzP9m4dVVUVLi5uQUFBR07duzo0aPdW+lrpq5MTExs0aJFcXFxeXl55ubmiYmJgo4IISRckpKSqqqqBg4cyM/CZIUICwsLGRkZskJEZWXlkiVLeKxC1kFQUlJSVVX18vKaPn16SEgIdbUUVYVBSkqqe/fuAQEBBgYGdTcye/ZsBoMhIyPj4eFhYmJy48aNZcuWDRgwQFZWdt68ebq6ulx9uXk/qJCQlpY2NDR8+fIl5yDmpUIBux7xQBCQnAwnToCXF0yfDg0V4hEVBQCws4OUFPDzAwmR7z9P0+lgYSHxOq3NwxUQWnWNRGoG2NoK5NHJGph2dnb85Ks+Pj715qshISEXLlx4+vRpQ92W29S2bdv09fVnzZp148YN8szwwYMHN27cGBgYyFksztPTU0FBYe3atS4uLlpaWtS4qKiojY1NTk5OQEBAfn5+RUVFVFTUgQMH6j6QgoLC6tWr4+LiysrKEhIS3N3dJSQkQkJCqDB0dXW9vb2vX79eUlKSmpo6ffr07OzskJAQ3lkKnwEMGjQoNTU1MzMzLi4uLS2NbB3O5743z/z581+8eMFms3Nzc3fs2EEQxOjRo/lfveUHnLetW7cqKyt7e3vfvn27tLT09evX7u7uXNN620dtba2Hh0dUVFRkZGSzGxWgehkZGcXHx2tra9vb22dmZgo6HISQEMnOzgaAHj168LMwjwoR9S7v5OREdXojmZmZVVVVUd+ROTg4xMbGenp6xsfHk9N3U1JS6pasHzx4MHVbU1OTa0RLSysrK4v/BxUe2traXIcO81KhgF2PuGRnw9WrsGYN2NuDkhIYG4OnJzx5Aubm0K9fPcV9xMRAWxtu3oTwcOjZs4GN/vgj/cUbGquyjWMXDInnqbTKShg/XtCBfKfefLWwsLDefNXPz2/y5MmDBw+Wk5Nr/3y1W7dujx8/dnFxWbRokZqampGR0aVLl65evTqZbDj0Hzk5OU9PT4Igli9fzrWF8+fPz5s3748//tDU1NTV1SWvCQQAe3t7zvcPWVnZP/744/fff9fQ0BgxYoSSktLdu3fJJjEAoK6u/uTJk2nTpi1evFhFRWXo0KFlZWWRkZFz584FgPj4eBqNdvXqVQCQkpLimpTLTwDBwcH9+/c3NjaeMmVKSEiIsbEx//vOG3kulIqNrGQQHR1tZGQ0depUZWVlY2PjmzdvHj58ePXqJrRravYBJ7/se/78+adPn2g02tq1a+uNUF9fPy4ubsiQIZMmTerWrduMGTO8vLz69evHZrNpNBrn5axtbe3atWFhYRcvXrT+dvkBajUqKioRERGqqqrjx48XyDdfCCHhRE7dqluyoV48KkTUu3yjdRD4rMLAWWReREREVFSUs/ykqKgo5+WjLS++0G5kZWW5/iBj/1IhUrfrUb3NBjul0lJ49gyePv367/VrAAANDbCyAktLYDBg8GCQlAQA8PODbdvgv6mIIC4ONBr4+oKvL9DpHFv8+WdgMuHq1W8jhYWgpVnqMLzcflh77VZ7IUA56ISYyQAIu/ZtsKICpKUhLAycnQUXWdNUVFRQlYE5FRYWkgtw1gfW0NDQ1NTU09MzNDQUyAmuZug0nc0a6l/aubVd/9JLly5NmjTp2LFjeKa0TaWnp5ubm9va2p45c0bQsSCEhEJoaOiUKVP4yYYGDBiQkpJSXl7O+aUwea4yKyuLvBiH611+xIgRDx48CAkJmTZtmqqqKo1GCw4OXrp06e3bt8kv5SlVVVX37t0LDAy8detWUFDQsmXLyHGuntsA4ODgEBkZyXmVjY2NTUJCApXg8f+gAkd+/R0aGkqNYJ8YJBjV1ZCS8jULjYmBZ8+gpgY0NIDBADc3YDBg+HBQUalnxaFDvyalIiJQWwu2trB/P+jo1FlOWRnevv1uREkJVvrI7NjOGmpaq9Ax0hg+ST56IZaRBZeufzf65QsA1H8QhZWUlBSZc3KN181XIyMjyfY25AJUvkolq3p6egYGBlgzBgm/8vLypUuXzpgxA5PStqajo3Ps2LFx48Z5enrWnSmHEEK8kRUiqD5tXBUiuHDWQaAGueogKCoqxsfHGxkZkVUYrKysZGRkwsPDqby0qfh5UGGGeSlqP1lZX7PQhw/h33+hvBxkZcHMDCwtYfFiYDCAnxboQ4YAANBooKkJ+/fD9/0LORgbw7FjQHzf0nPlStqff8peu1/sPrYV9kc40Fhs2WsPYN484JoH/uoVAICRkUCial3856sxMTGYr7abX3/99ddff5WRkencEyNXrVq1ffv2ttv+9u3bCwsLt2zZ0nYPgShjx451cnJatGjRs2fPWn75NEKoSyErRGzatKl///5JSUmzZ8/mrBDBhayDcPfu3YCAgJkzZ8rIyMTHx9etgzB//vzdu3cbGhoymcz9+/c3tQpD8x5UaOE83qa5cuUKWTATANLT01euXBkRESEhITF27Njdu3czmUwvL6979+7Jyso6OTnt3LmT8+NvXl7epk2bwsLCsrKyFBQUrK2t169fz3n9NOfZ/8DAQHI6OEVUVLSFtTHbH5MJL19+TUQfPYK8PBATAwMDYDCAwQArKxg4EESafo2zsTG4uYGvb4M1kAAAnj+HAQPg8eOviSzl0iWYNKnYw4k1rF+TH1gIEYTiwb8lsgshKYn71OjKlXD1KgiosqhgsVisrKwsrsnAjearffr04byEo3Vx/UavWbNm8+bNbfRYHULdjjWUDRs2+Pn5tWMsglRYWKitre3n58f1Bx+1nTdv3piYmBw9epSrnztCqAtq0jze/Pz827dvL126NDY2trq6eujQoVu2bLG0tIQG3uXz8/PXrl0bERGRk5OjrKzs6Oiorq7u7+8PAAwGIyEh4fnz5/v3779//35GRoakpKSBgcHs2bNnz55No9Hi4+MtLCw4N+ji4jKE4zPttm3brKysOEsSkO+ejT5oaxy21lF3Hi/mpc1BzvZ2dXVdvXo1WSPk559/dnR0lJCQ8PPz69279+nTp+fPn7906VKqU192draFhQWLxTp69OiIESMyMjIWLlz46NGju3fvUi+7TnB9aVUVvHgBDx9+naCblAQE8XV2LnWlKK9kkj/FxdB4+kAQoKMD06aBvz/3XatXQ8COokVTKw16tTQUQZP9+470w2cQFQUcf7wAAGprwcAAXFwgMFBAoQmjuvkqmay+f/+e/EtI5qucyWpb56uoiwsJCVm3bt2nT5/wHH57mjx5cnZ2NtkkECHUlTU1L+0EFSKEB+alrYPMS8PDw8eO/Tod1NTUNDExMTo6esSIEeSInp6ehIQE2bsPAGbMmHH8+PHTp0+TFSMBICcnR0dHx9TUlPrqoiPmpTU1kJz8rV7RkydQWQkKCjBkyNcsdNgwUFMTUHB+frB/P7x/DxxVywAAamvBzY249U+Rp2tVb74qgwsjAmQiHshEPITTp2HaNO57IyJg3Dh49YqvudFdXvPy1d69eysoKAg6dtSx2djY9OzZ88SJE7wXS05OXrVqVVRUVFVVlamp6fr164ODg+/cuQMAs2fPPnLkSHV19d9//33kyJGXL18ymczevXvPmTPHy8tL5L8ZKWw2e8uWLaGhoR8+fJCUlLS0tJw7d+64ceNEyRZbXUxYWNjEiROzsrKwSSxCXRzmpQKEdY9aE1c3ocTERK5uQs+fP6d+vHLlioiIiBPH1ZDq6uomJiZPnz79+PFjx2pbSl4mSv57+BCKikBGBgYMAAYDPD2BwYC+fetp5SIACxZAcDD4+8PGjd+Ni4jAqVM0d3el3WeLpzt2xAm9tAXPiF8AACAASURBVKpq+VMR9H+T4eDBepLS6mrw8QFnZ0xK+SQpKVnv9at189XExMTIyEjOfJUrWcV8FfGPxWKRnet4L/b27VuyjfvFixctLCwyMjK8vb1fvHhBp9NZLBa5zM2bN6dOnbp169bQ0NCampqzZ896e3t//PgxICCAXGDRokUXLly4cOGClZVVcXFxYGDghAkToqKiumb5Hzs7O1FR0Xv37k2ZMkXQsSCEEPoK89Lm47+bEJvNZjKZAFDvp9U3b94IeV5aXAwvXnwtWXT/Pnz+DKKiYGgIDAb4+QGDAUOHgoSEoKOsq1s3WL8e1qyBmTNBV/e7u6Sk4OJFWLNG3t9f4u2H0vE2tfJ8ta4SBuLvMuUuRIoxy+HmTbC1rWeJ/fshNRX+/rvdQ+tsGspX2Wz2p0+fOE+ukiWCeeer+vr6dVufoa4sKSmpqqpq4MCBvBdbvXp1UVHRkSNH7O3tAcDExOTMmTM6daqQ29jY+Pr6kre9vLweP35MThIm36ru3LljYmJCbkFKSiogICAsLKzV96ijkJaWNjQ0fPnyJealCKFGcV47SqPRsEJE28G8tD3Q6XRFRcXS0tKKioomFQDkURqkTVVVQWrq13pFT59CcjLU1n69THT+fLCyAgsL4K8FsaB5ecHhwzBnDty8CeLi391Fo8HWrTBkiOTixfSNh8rGWFRYDyIkhTC9/kY0t0Am4qHkk8Sv7XF6965noeRkWL8eli0DA4N2D7CroNPpTcpX09PTyW+pMF9FnMhCXD16NHI1wc2bNwFgzJgx1IiampqRkVFiYiI14uTk5PR9dXIzM7NTp04lJiaSJQwcHBz279/v6ek5a9asIUOGiIqKpnTJomgUbW1tqhAaQgjxsGLFihUrVgg6ii4B89J24urqevTo0ZiYmJEjR1KD27dv37t3b1paWkPJqrS0dCXZrBPA0NBw+fLljc74ara0tG/1ip4+BRYL5OWhXz+wswM/PxgxAjrkZTji4nDxIgwfDvPnw59/1rPAxIkwZgxtxw7ZHdtlbsay+/Wp7Ktb3VO9RlFeKHJUghApqxDNLRRP/0R/+U48NR10deDKFRg/vv7lCwpg/Hjo3RvWrWvXOBEAtCBflZSU5EpWMV/tCsrKygBAhueXfGw2u6SkRFJSUlb2u67LSkpKnD8ymcygoKDLly9//PixqKiIGi8vLydv7N2718LC4vjx47a2tgBgbW09b948qrx8FyQrK9u5+xshhFCHg3lpO9m2bVt0dPSsWbP27NkzfPjwmpqaCxcubNy48dixYzzOoA4aNCguLi4zM/Pjx49paWmcxaBbjvMy0dhYKCgAcXHo0wesrITsMtEWMjGBU6fAxQV0dWHt2noWkJYGPz9YsoR24gT90iXJk+FQU9PuUTZGURHGjIHA3eDoCA3VKSkuhgkToKoKwsO5Sz0hgeInXyUrLfGTr+rp6XHlJKiDImd9854XQ6fT5eTkSkpKSktLOVPT3NxczsWcnZ0fPHgQEhIybdo0VVVVGo0WHBy8dOlSqpgHjUbz8PDw8PCoqqq6d+9eYGCgq6trUFBQs7u3d3Q0GtZ9RAgh4YJ5adNwdhOSkpLi6iZEo9G4ugnRaDSym1C3bt0eP368ZcuWRYsWZWZmKioqDhw48OrVq3Z2dtDwzPXg4OC5c+caGxsrKyuHhIQYGxu3JPiSEnj+/GsiGhMDaWkAAHp6YGkJ69cDgwFDhgCd3pJHEFbOzrBnD3h5wYcPsHcv94RekpISLFlCW7IE2Gx4/Ro+f4aSknYPtA4REVBUBF1d0NVt5EuC9HRwdoYvX+D2bejWrb3iQy3SuvkqOUNYEPuB2pajo2NoaOjNmzcnTZpEjuTk5KSmplIL1NTUxMTEqKurL168mBqsqKjg3IiiomJ8fLyRkZG4uLi9vb2VlZWMjEx4eHiXzUsRQggJG8xLm2bYsGF1v2HlZwQAlJWVg4KCgoKC6t7V0Mx1Q0PD+/fvNzdYqK6GlJSvWejDh99dJurhAQwGWFqCsnKzN9+h/PoraGvD9Onw7h38+SfUKRnyDZ0OjZUhEToRETBzJmhqwqNH0Ni1akj4NZSvVlZWklMnqGQV89WuYOvWrZGRkd7e3goKChYWFunp6b/99pu6unpOTg65gKioqI2Nzd27dwMCAmbOnCkjIxMfH3/gwAGu7cyfP3/37t2GhoZMJnP//v0EQYwePbrd9wYhhBAvwt8ksu1gXtrZkLNzyUT0f/+DigqQk4P+/cHODnx8wNqauzBtF+LsDA8fwtSp0LcvrFgBq1Z1hsmub97AsmVw/TpMmwaHDsH3V6ChTkZCQqJJ+WpGRkZNTQ00nK9qaGgIqrga4p++vn5cXJyPj8+kSZOqq6sHDBiwbdu2DRs25OXlUcucP39+7dq1f/zxx5o1a5SVlR0dHadPn+7v729vb89gMBISEqKjo/fv3z916tSMjAxJSUkDA4PDhw/Pnj1bgPuFEEIIcWpyXvrxI4SFwd278Ow55ApuqqOICCgogp4eMAbBmDHg6AhSUoKJROCKiiAh4WvJovh4yM8HMTEwMAAGA37+GSwtwdgY/uus3uWZmcGLF/DHH7BxIxw4ADNnwqRJMHhwx7uOtrwcIiPh5Em4ehWMjCAqCrpkE0JEasV8lTy5qquri/mqUDEwMLh8+TLnSHZ2tqqqKvWjqqpq3ROk27Zto26bmZnVXQAhhBASHk3IS1+8gPXr4fp1kJIiho+oHj+pWl2TkJUTTNkAohaKCmnpaSJPn4j9+aeYnDzM8wRfX+gK3ezLyuDff7+VLEpKAoIADQ2wsoK1a4HBAAaj62bpjRMXh2XLwN0d9u+Ho0dhxw6QlwcTE1BVBUlJQQfHh+Ji+PgRUlOhpgaGD4djx2DKFGhK8yHUdfDOVzmTVcxXhVlOTk7fvn0/f/4s/t+18enp6e/evXN3dxdsYAghhDjl5eVt2rQpLCwsKytLQUHB2tp6/fr1AwYMAIArV65QJdDfv3/v4+Pzzz//iIqKWlhYhISE6OvrA0e5mZiYGPLdVlRUtLq6ukkbT05OXrdu3Z07dwoKCsi1OL/EFHJ81aMrKIB16+DgQeg3oGbuItYPjpXiQtBBg5KfJxJ6SuLP/ZIiIrRtW2HmzM52erCmBpKTvyWiT55AZSWoq8PgwV+zUAsL6DgvOSHz/DnEx8Pr11BYCCyWoKPhg5wcdO8OZmZgY9MxW/cg4VVVVZWZmcmVr6alpVH5Kp1O19LS4kpW9fT0MF9tntDQ0ClTpjT6LpyTk6OhoTFz5szff/9dRUXl1atXXl5eb9++ffLkSd0vHRCfJk+eDAChoaGCDgQhJEh8/h3mR3Z2toWFBYvFOnr06IgRIzIyMhYuXPjo0aO7d+9SNVNdXFyuXr06YcIEHx+f/v37x8XFjR8/3tTU9PHjx9R26r2+lP+Njxw50s/Pb+jQoS9fvrS0tMzJyVFVVR09evTz58/Dw8OHDRvW8j1tLXX/Djd+miUuDlwmAo1G7Nhd7jq1Ugg/e6iq1S5YyvppJjt4u9T8+fRz5+FCKHT0tn9UE5eYGIiNhfJykJUFMzNgML42cTExEXSInYOZGZiZCToIhISCuLh4vedX681XOc+vYr7aptTV1SMjI/fu3TtixIisrCwlJSU7O7szZ85gUooQQsLD19c3IyPj9OnTY8eOBQATE5Nz587p6Oh4eXklJCRwLjlnzhwymbSzsxs3btzFixfz8/N5n9Xkf+M+Pj42NjYAYG5uTp1rra2tJQhC+JtjNZKXnj0Ls2aBlU1V8MEyQU3Z5ZOCIrFhW/mPU9lzf5IdZiESfh309QUdU1MwmfDy5dd6RY8fQ24uiIqCoSEwGLB1KzAYYG5ef38ThBBqUzzy1by8PK6Tq5GRkR8+fCDfCxvKV3V0dEQ62bSWNmZra2trayvoKBBCqCt69epVv379qB8XLly4Z8+euotduXJFRETEycmJGlFXVzcxMXn69OnHjx+1tbWpcarBJAD06NEDALKysnjnpfxvfOjQoXVXv3fvHs9dFBa88tLDh2HePJj9K8v39wpR0XYLqUVMzWquRJbM/UnWwkI0Lk6oU9OqKnjx4mu9Is7LRBkM+PVXsLKC4cM7Q71YhFBnJS4urqmpqampyWAwOMeblK9SySrmqwghhISQqalpo2ca2Ww2k8kEAIX6St28efOGM3XkXEZCQgIAyGZvrbJxGRkZ3qEKswbz0jt3YOFCWLKS5e1T0dAywqm7eu25ayVTneXGOYnGxwnRhF6uy0QTEoDNBgUFMDUFZ2fw9wdzc+jWTdBRIoRQy2C+ilBHcerUKQ8PD/K2jIxMaWmpYOOpi6oEo6Wl9fHjRz7XOnfu3LRp0wCATqez+Cge8ejRo82bNz99+rS0tNTU1HTKlCkeHh7KwtfhvXlHQ4Ba8elbtWrV9u3bydvm5ubx8fFtEG/z0el0RUXF0tLSiooKsZZVo6x7/UsrblzI1f9O//YtuLnB2PGVS1Z2sKSUJC1NHD5dWlxcO8kNeH4B0eaysuDaNfDzA2dnUFMDU1OYMwdiYoDBgEOH4NUrKCyEhw/B3x+cnTEpRQh1ZmS+ymAw3NzcfHx8Dh48ePv27Xfv3lVVVRUUFCQkJJw8edLT01NPTy8tLe3kyZMLFy60t7fX19eXkpLS19e3t7efN2+en5/foUOHIiMj09LSeH/BjJqktLS0T58+nJPEEP/a6Oi125Oyf/9+giCopFSoXgwrVqwgCMLs+0oQjUY4depUgiD4nP0eExNjZWVVW1sbExOTnZ29ZMkSHx+flStX8hlhex6ueo+GMGvFp8/f35+8QlJUWOdwurq6VldXx8TEcA5u3769Z8+e1HWe/JCWlq6srCRvGxoaHjp0qBU3LuTqz7kXLgJN7Zode8o7bsWK7uq1h0+XutjLHzsG7dk5vKQEnj//ekb0wQNIT/92meiGDcBgwJAhQKe3XzwIIST8lJSUGAwG1/lVACgsLEz73sOHD9+/f19RUQEAEhIS2traXCdX9fT0evXqJbQfXIQWQRC1tbVcqX69ZSFRXfUePaHdrNA+Lv9aN8IjR45UV1cHBwfr6uoCwJQpU+7fv89mswUSTFfQWY/Ytm3boqOjZ82atWfPnuHDh9fU1Fy4cGHjxo3Hjh1r0knOQYMGxcXFZWZmkh3Ira2tW75x4azHW1c9e3L1Kty+BeevldPpQl3oqFGmZjU/z2H7rqb/+GMbzuatroaUlK+Fcx8+hORkqK39epnoL78AgwFWVqCk1FaPjhBCnRj/+erTp0/T09PLy8tBOPLVGzdujBkzpgNNP5aTk3v37p2go+io2ujoCepJEf4XQ+tGSF46mJOT06dPH3Jk7969ggqmK+isR6xbt26PHz/esmXLokWLMjMzFRUVBw4cePXqVTs7OwCIj4+nGrpISUmtWbNm8+bN1JTdgQMHjhs37vr16wAQHBw8d+5cY2NjZWXlkJAQY2Pjpm4c/ntVU6qrqztkPd6aGli+Asb/WDl0eGc4KbxkZcXVixL+/jR//9bcbFbW1yyUPC/KYoG8PPTrB3Z24OcH1tagrt6aD4cQQohTS/JVrmS1LfLVyspKJyenPn36bNy4cdKkSR0oO0WoC3J1dT1+/LiXl9fDhw9lZWUFHQ7qwJSVlYOCgoKCgureNWzYsLppYb2JoqGh4f3791u+cU71blAIcb9ZhodD2jtYuqpDXlZal4IiMftX1qHDUNGyHcrO/naZqKoqaGnB9OkQGQkmJnDw4LfLRENCwM0Nk1KEEBIMMl/lvH41MTGxrKyMvH711KlTnp6eJiYmFRUVkZGRS5cuJa9flZaW1tfXt7Kymjx58qpVq6jrV8nurM2QmZlZW1v75s2bqVOnGhoanjt3rh1mrOXl5S1evFhHR0dCQkJNTc3V1fXZs2fkXVZWVrT/uLu7A4CdnR01UlRUdOXKFepHsspIYGAgjUYrKyuLiYkhxzt3sY2WqHv0SF++fFm2bJm+vr6EhISSkpKjo2NUVFTdVdLT06dMmaKoqKiiouLk5ESdR6p3s4qKirQ6REREqIoyPF4GLdkdNpu9fv16IyMjaWlpZWVlZ2fnsLCwRn9BioqKOOPcvHkzAFRXV1MjkyZNIkfOnz9vb2+vrq4uJSXVr1+/kJAQHr8yDR3w5ORkFxcXBQUFGRkZa2tr/uef6+vry8vLP3/+fPz48fwUSWo0mOYdLlJTjwY/D8fjpchDR3n6UKdCfG/qVGL4iKr0goJO8y8hpUhUlLh0iWiSkhLiwQMiOJjw8CD69iUACABCQ4NwcyOCg4kHD4iKiqZtECGEkLAh89XQ0FB/f39PT08nJycGg0EV2Scbt1paWnIVaqImRDXk9u3b1JusiIgIjUbr0aPHwYMHq6qqOBc7f/583Xfh5snKyurVq1f37t3Dw8NLSkpevXo1cuRISUnJ2NhYcoFnz57JyMiYmZmVlpYSBMFisczNzc+ePcu5kQkTJgBABcfbm4yMjKWlZd2HGzVqlLKyclxcXKsELxBubm5ubm6tuEGuo5edna2rq9u9e/dr164xmcyUlBRXV1cajXb48GGuVSZMmBAbG1taWnr79m0pKakhQ4bw2KyCgkJJSQl178aNGwFg69at5I+NvgzqOnnyJPxX94jH486ZM0dBQeHWrVvl5eU5OTkrVqwAgKioKH6OjIODg4iIyNu3bzkHLSwszpw5Q96+du0auRcFBQV5eXm7d+8WEREh6+VQzMzMtLS0eET45s0bRUVFLS2tW7dulZSUvHjx4ocfftDR0aHT6bzDu3v3rrS0dHBwMLlBJycn6vd03Lhx1C/yjz/+yGMjrXi4mnE0eD8cPy9FHoTw6RMVFTU3N+cneH604t9h1FR1/w5/90zU1hKKSsT6LWUCTyZb9x9jaLWnZyOHpqqKePWKOH6cWLyYYDAIEZGviaiTE7FhAxEWRuTnt/rTgRBCSBg1mq9qaGjUW1iYXP3w4cNcZxfrzU5b8fPQL7/8AgCnT5+mRrKzs+l0OoPBoEZCQ0MBwNXVtba29pdfflm9ejXXRvjPS0eOHKmkpMQj2xF+bZ2XzpgxAwA4M38Wi6WpqSklJZWTk8O5yrVr16hlyBNQeXl5DW2WMy89f/48jUabMWMGtTA/LwMufOalurq6w4cP51zAwMCAz0QrMjISABYsWECNPHz4sGfPntQvwrVr12xsbDhXcXd3FxcXZzKZ1EijiY2bmxsAXLx4kVrg06dPdDqdd16al5enoKAwZswYgiBYLNbo0aMBYOrUqTU1NeQCaWlpUlJSjX4V1YqHqxlHg/fD8fNS5EEInz7MSzuNun+Hv5vHm5YGRYUwaGgzZy4JrQGMqv/9W8842cRl1SqwsvraR3ThQnj6FCwt4dgxePXquy4vKirtHjdCCCFB4JoPfO3atYSEhJKSkk+fPj18+PCvv/5atGgRg8FgMpmXL19evHgx53xgW1vb48ePc12wWltbSxDEp0+f5s+fr6ure+jQIT4r+7969YpzKt2iRYvqXezKlSsiIiKcfRfU1dVNTEyePn1KzfB0c3Nbs2bNpUuXrKysvnz5smnTpuYeHrh3715BQQFVZgPVdfnyZQDgPOFGp9NtbW0rKir++ecfziWHDBlC3e7RowcAZGVlNbTZoqIi8gLIR48e/fLLLyNGjDh48CB1Lz8vg+ZxcHCIjY319PSMj48nJ4impKTY2Njws66tre3AgQP/+uuvL1++kCMBAQHe3t7UdzdOTk5c00rNzMyqqqoSExP5j/DmzZsAMGbMGGpEU1PTwMCA91rHjh1jMpk//fQTANDp9KtXrw4dOvTcuXPz588nF7h3756VlVVTrz9vyeFqxtHg/XD8vxTrJcxPH+p8vstL378HAOil29nyUl392rQ0AAAmEyIjv+aZ3bqBlha4usK1a6CnB1u3QkICMJlfLxP9+WcwMRF03EKPvACJRqNpa2u3ZJkO4dSpU9RHQ866CKGhoTQajY7Nf+rTvGf/3Llz5FqSkpLU4KpVq6jjL+RVzlFnRaPRNDU1LS0tp0+fvnr16oMHD/7zzz8pKSkVFRWfPn2KiYk5fvz4nDlzevfuzWQy6007ObNTHR0d8kQEb6amppzfJe/Zs6fuMmw2m8lk1tbWKigocCax//vf/wDgzZs31JKbNm0yNzePjY11c3PDakxth3xGJCUl5eTkOMe7d+8OADk5OZyDCgoK1G0JCQkAaPRq5A8fPkyYMKFHjx6XLl0iV4GmvAyaYe/evSdOnEhLS7O1tZWXl3dwcCCzHT4tX768vLx83759AJCamnr//v05c+ZQ9zKZzPXr1/fr109JSYmM+bfffgMAslwZP9hsdklJiaSkJFfVom6N9YVPTU2F/54XAJCVlb1x44apqenhw4eXL19eU1MTEhLCGSqfWnK4mnE0eDxck16KDRHapw91Pt+9LRUXAwDIybdHEeFDe/boKCvrKCsPa0r+d+3SJXItAw0N/teSVyCYRaCrC4qKYG8PZ86AggKsWQOxsVBSAomJcOIELFkCDAbg23ST8NPfuXktlYUWV/NxAFBTU6P+p3TcHWxdXaqhNuqyyHx1+PDh06ZN8/X1PXjwoLS0NI8aJ+Qr+dOnT4cPHwaAY8eOVVVVtSQAOp2uqKgoJibGdf0qadSoUdSS9+7dYzKZ/fr1W7BgwfPnz/nZtZYE1mXR6XQFBQUWi1VSUsI5/vnzZwBQb1l1xJKSEvIayOvXrysrK3M+KJ8vg2ag0WgeHh6RkZFklSyCIFxdXXfu3Mnn6lOmTOnRo8eePXvYbHZQUNDcuXM50yRnZ+dNmzbNnTs3NTWV/O5m165d0ECp0nrR6XQ5OTkWi8X57gwABQUFvFdUUVEBgKSkJGpEWVn51q1benp6O3futLCwkJGRIaeYNklLDlczjgaPh2uVl6LQPn1dTac508PDd3kY+fVu+5Tc81y0KL2gwNjUlHOwrKzMZvDgWVOnNrSWs6trekGB5ciRTXosEVGoqYFZs+DmTfjyBVJT4dQpWLIELCyA43wMaj9EO7ZUlpWVtbKyarvt15uXtucO8q+tDwWfhPPgINSK0tPT6x2n0Wji4uLkjV69eo0YMQIA+vfv3/JHdHV1ra6ujomJ4Rzcvn17z549qTO379+/nz179t9//x0WFiYlJTVhwoS8vDzem5WWlq6srCRvGxoaHjp0qOWhdhETJ04EgPDwcGqEzWbfuXNHSkqKc7JiU9XU1EydOjU5Ofnvv/+mZjlOmjTpypUrwN/LoHkUFRWTk5MBQFxc3N7eniypyrl3vImJiS1ZsiQ3NzcoKOjcuXOLFy/m3KOYmBh1dfXFixerqamRX4VUNL2JgqOjI/w3HZSUn5+fkpLCey3yadq1a1dhYSE1qKGhERkZqaio+OTJE7JydVODafbhat7R4P1wLX8pCu3TJ/yGDRvWiqco+Dkb1NEJ2fnBtvzAum4djBkDHN8tIoEhWypHREQIOpBWUG9e2pl2sNXhwUGdW2VlJWe+Jy4uTn5Wk5OTs7OzW7t27Y0bN758+ZKenr5w4UIAYDAYZLLaEtu2bdPX1581a9aNGzeYTGZBQcHBgwc3btwYGBhIXgZWWlrq4uISHBzct29fHR2dixcvZmVlTZo0ifep2kGDBqWmpmZmZsbFxaWlpVlbW5Pjo0ePVlFRiY+Pb2HYndi2bdt0dXW9vb2vX79eUlKSmpo6ffr07OzskJAQatZoMyxdujQiIuLQoUP1XqzY6MugJebPn//ixQs2m52bm7tjxw6CIMgqQXzy9PRUUFBYu3ati4uLlpYWNS4qKmpjY5OTkxMQEJCfn19RUREVFXXgwIGmhrd161ZlZWVvb+/bt2+Xlpa+fv3a3d290Wak5ubmq1atysjIsLKyioiIKCsrKy8vj4mJWblypYyMjJKS0qZNm44fP97UYKC5h6vZR4PHw7XKS1E4nz7UckJyxuIbzmke588TAER7Vso1NjVV19Bo6lqWI0dK0On8L7/naCmW2mo7dcusNW+ZNtJQPcmmaqhoIdnLa/r06S1/iLbWWoeiqZr37Nva2rZDIT6EWt3bt2/Jt1cxMbEBAwZ4eXmdPHkyNTW17pKtWweSbFGop6cnLi6upqb2ww8/3L59m7yLTIBJL1++5DpNumnTJq6L33766SdyxeTkZGtraxkZmR49euzdu5d6LGtra6zHS2no6OXn53t7e+vq6oqLi5NFX+/cuUPeFRcXx7nKmjVriO8nPY4bN67uZhMSEhr6LHf58mVyyzxeBvWq+9ZW7+48e/Zs3rx5xsbGZIfMYcOGHT58mJy0yT/yssPnz59zjefl5c2bN69Hjx7i4uLdu3efMWPGqlWryEdnMBgBAQFcx6qhA56SkuLi4iIvL0+227l+/Tp1Pcjs2bN5BHb9+vWxY8eqqqqKiYkpKipaWloGBQWVlJTExsZKS0tTD1TvBOlWP1xNPRr8PByPlyL/hOfp4/NjwLx589avX5+UlMR7sTatx2tubj5u3LjW3WbrfqIW1CdDUiN9YjAv7WpYLNa6desMDQ2lpKSUlJScnJyuXr1K1kOnSjVSr9cbN26QIyoqKpwbIX9DkpKSxo4dS/5BsbGxefjwYd1lyNucf5LIEuGcI+np6ZMnT5aVlVVWVnZ3dy8oKHj//r2Tk5OsrKy6uvqcOXOKi4upzVZVVZ07d87Ozq579+6SkpKmpqbBwcFUeXeuv4YAICoqSq2bm5vr5eXVq1cvcXFxVVXViRMn/vvvvzyOVUN5KUEQysrKS5YsoX6su4O8DzVvnFt7//795MmTFRQUlJWVx40bx9VPLD8/f+nSpeTHEUVFRQcHh7t37/JzKOrFOakJADZt2kQQBOepFbKZG++ngMT72SclJSVNmDBBXl5eWlraysrqwYMHmJeiDurdu3e7du2KjY2taKzPNfYnEKBW7xPTQfF4YAlQ8AAAIABJREFUa0NIOPH5MWDkfxf99e3bNyAg4MOHD/UuhnmpUOWlLZrHW8lm79y2bfTQoUaammZ6erOnTbt94wZnsYfCgoJNa9aMGDSod/fu/XV1f3Fzi3vwoKGt3QoPJ2sa6Sgrs9lsavzdmzdz3d1Ne/Uy1tJyGzv2CU4caj2LFi3avXv3H3/88eXLl6SkJCMjowkTJjx48AAA1q5dSxAE1a8PABwcHAiCYDAYdbdTWlq6YMGC1atXf/r06f79+wUFBaNHj46Ojq73QV1cXIj/WlfVHVm2bNnKlStzcnKCg4NPnTr1008/eXt7b9q0KTs728/P78iRIxs2bKBWvHnz5tSpU0ePHp2UlJSZmenp6bls2TIfHx/yXnIiPuevHHWBTXZ29pAhQ0JDQ/ft21dQUED1POD6DptPampqnPN46+4g8DzUvHFuzdvb29vb+9OnT+fPn7979+60adOoxXJycoYMGXLmzJmQkJD8/PxHjx5JS0vb2toeOXKE96FoiKKiIsHRUHvt2rUAICYmRvzXUPvixYvQ2FPAe3cob9++tbCwSEhIuHjx4ufPn/ft27dp06Z37941enAQEkJ6enre3t4WFhaSWMAAIYQELSkpafXq1b169TI3Nw8JCcnNzRV0RA2qrq4+f/68vb29urq6lJRUv379QkJCGr28MS8vb/HixTo6OhISEmpqaq6urs+ePSPvIi82JqWkpEyePFlFRYX8kWxzUFZWFhMTQ460fLZ/K+BMUpt6vnSqh4ecvPzJS5eSs7ISUlI8Fy0CgHNhYeS9T5KTe/Tqpaqm9ufZs68yMqKePHFwdqbRaP4hITzOl9qPHQsAKdnZ5I/3EhLkFRTUNTROXrqUmJl58+FD61GjtHv2xPOlraLR1s91v0dhMBh1z5cCQFxcHDXy4sULADAzM+NchndLZWokPDycGjExMQGA6OhozoANDQ2pH/np5lzvV0Gt2HycIAhLS8s2bUpO8NF+nZ/G2c34VqzTN9RGSIDwfKkA4flSEvnWRpKRkRF0OAg1iPMr7yadL6XQaDRRUVEREZFRo0YdP36cnH8nVOdLr127BgBbt24tKCjIy8vbvXu3iIgIeWqBwvWZKisrq1evXt27dw8PDy8pKXn16tXIkSMlJSU5r7MgP3SNHDkyKiqqrKwsPj5eVFSU/ADZqc6Xxty/b2BkZG1jIykpqaqmtnrjRl19fere7Rs3ZmZkbNi2zXbMGFk5OV19/d2HDnXr3t3Pxye/sRqAlIBNm4qZzA3+/tY2NjIyMkZ9+wbu3Zv7+XNLwkaUlrR+5iQpKWlubk792K9fP01NzefPn2dnZzd1U4MHD6Zua2pqco1oaWlxNhxvdjfn1m0+LiYm1uiXTK1yqHm0X29h4+yGYENthJqKzWYPGjRo/fr1T548wbrTSMi5u7tTnwi5unTwidYwPz+/1o63wxO2wyVs8fBAtYsjCKJ5RdcIgqipqamtrb1///7MmTNVVFTGjRvXuvXbxMTEOI/ho0ePwsPDOUca7c1jY2Pj6+urpKSkqqrq5eU1ffr0kJCQYrKTZ318fX0zMjJ27tw5duxYWVlZExOTc+fOEQTh5eXFtaSPj4+NjY20tLS5uXl1dbWqqmor7HBra1FeOtLW9unjx77e3v8mJJAftaOePBn2X1mnf65fB4DRP/xALS9Bp1uOHMlisaLv3OHzIe7duQMAIziKmHVXV9fjyH5RS7SwUzaFnBXAOUJ2Q27GZAl5eXnqtoiIiKioKGfVAVFRUc7Pec3r5tymzccb0iqHuqH2663SOLsh2FAboSah0+kvXrzYsmXL0KFD1dTUZs+efeXKlbKyMkHHhbjFxcXx+FCO+MTjCP/++++Cjk7oCNvhErZ4WlFaWlpDu0Zmp1VVVREREWS3VV9fX6onVktw1Q2pe76U90eyZnzXz/+JlqFDhzZ3t9pPi2YSbwoIGDRkyN/nzk2fMAEAhlhY/DRjxhgnJwCoZLNLiovpdLrM9581VdXUACCPv3Slks0uKy2l0+mcVzkCgIqaWhpee9YaaDSah4eHh4dHVVXVvXv3AgMDXV1dg4KCli1bRi4gIiLC9YtaVFRUdztMJpNrhMxI2zq1cHZ2fvDgQUhIyLRp01RVVWk0WnBw8NKlSwmOwoa0On92yebjpaWlFRUVrTKZ/t69e40u0+ihbgmycTaTySwpKeFMTbkaZ9c9FPyYMmWKr6/vnj17Vq5cWW9D7UafgkaDl5OTKykpKS0t5UxNsaE26rikpKTIU08FBQUnT548duyYmJiYpaWlg4PDxIkTcS6AkDAwMNi5c6ego0AItYkdO3ZkZmY2dC95noNOpw8ePPjhw4cbN25seb+ulmMymUFBQZcvX/748SPn5+2GvusnT0vA9+ctKG/evNHW1qZ+5EqmhFOLPpTTaDTXKVNcp0yprqqKi4k59Mcf837+ee3mzXMWLJCg0+Xk5UuKi8tKSzlTU3IGrxp/6YoEnS4jK1tWWlpWVsZ5NIu+rxSKmk1RUTE+Pt7IyIjsxWxlZSUjIxMeHk4lSxoaGp8+faKWz8nJ+fDhA+cpTVJpaenz58+pVr8vX77MysoyMzPT0NBou+A5uzlTg3W7OXP1hV++fLmnp6erq+vRo0djYmI4Lz/Yvn373r1709LS2uLK70YPdQtNnDjxr7/+Cg8Pnzp1KjlSt3F2vYei0S2TDbVXrFhBNtR+/fo1dRefT0GjHB0dQ0NDb968SV40C52loTbqsqSlpakpkWQV66qqqujo6AcPHqxatapHjx4TJ050dnbmLBOI2p+Kigp5cTtCqPPZu3dv3UFRUVEAoNFodnZ206ZNc3V1jYiIePjwoTAkpdD07/pbfqKleWcs2k6L5vH209F59+YNAIiJi1vb2Bw+fZpGo929dYu8lzxxSv0IAJVsdkx0tKSk5Mj/WhI1apSdHQBwzvst+PIlrTkzLZO8vLx+//33ffv2Xbx4MTo6OjEx8fPnz/ixgHfr5x9++CErK2vPnj2lpaXv3r1bsmRJvadAZWRkFi1a9OjRo7KysoSEBHd3dwkJiZCQkDaNnM9uzvX2hW/F5uNPnz5VVVW1srJq9EKyFjYl542fxtn1Hgp+YENthJqE8+oDCnlpEwBkZmbu27fP3t5+7ty5APD33383Wh+7GYYNG8Y5swshhLosGo0mLi5Oo9EYDEZQUFBWVtaNGzd+/vlnofqkwfldv5qaGpkxNvpdv6ura3V1dUxMDOfg9u3be/bsyc87C9cZi0OHDjU3/FbCOem5qfV45eTlzS0tbz54kJqd/TQlxdvHBwBWrFlTtx5v4ocPVD3ebcHB/NfjjX76VFFJiarHezsubsTo0Spqak2vxxtjbW1tbGzM2c+DpKamZmxsbG1tPXHixHnz5q1duzY4OPj06dO3bt169uzZx48fWSxWaxSdEkaN9mIuKiqaM2eOhoaGlJSUlZXVkydPqD4xPj4+VFdMLS2tx48fjxo1SlZWVkpKauTIkVT/Un5aKtftMP7kyRPOkW3btnG1VNmwYQPRWDdnMoCG+sK3vPk46cmTJ+Sho5p2tm6XbX7ar5NLNto4u6FDwY8O11AboWZgs9kFBQUZGRkpKSkJCQnR0dH//PNPaGjo8ePHDx486O/v//vvv/v4+Pz6668zZ850c3NzdHQcNWoUg8EwNjbW1dVVUlKSkpICAK4rvesSERGh0WhkI5mXL1+2xb60Rd+8zgTr8SLUuZET4siTDQMHDty1a1dWVlbdxYSqHi95umLHjh15eXnl5eV3797t2bMnAHB+QOWqx/v582d9fX09Pb2IiIiioqIvX74cOHBAWlr6/Pnz1DJ1W2BQHBwcFBQUPnz4EBsbKyYm9vr162btaDPV/TtMIzg+44aGwpQpkF7A7yzZpFevTh49+jg29lNmJl1SUldff4qHxxR3d+qkcGFBwR9BQbcjIrKzsqSkpAYOHjx/8eLhI0YAwKE9e7auX09tatHy5f0HDPD08KBGXNzcgg8eBID3795t8/OLvX+/uqrK0Nh4iY/Pn/v3x0RHA8AUd/ftu3c3Guf1KxKLZslQO1pTU5P/n9zc3Ly8vLy8PPLHz58/U3eRk69IcnJyqqqqqqqqysrKKioq9f6vqqqqqKjI56FDHc6pU6c8PDz2798/f/58QcfSpYmJiQ0ePLh1C+ihjq6iooLFYpWWllZVVTGZzOrqaiaTSQ4WFhay2ezy8nImk8lms0tLS0tLS1ksVnFxcXl5OYvFKioqYrFYFRUVRUVFRANzpf7f3p3HRVX9/wM/d2YYZoMZGDYzQ7MExCV3CPhKgoaCgfxSM7VScUFBjId+1CT0obiQuAYp2jerb26oiX4ErTSwBDExRc2PGwqoiLLIOjhs9/fH+Xa/04Ajsl3A1/MPHzPnnnvu+44w3Pc9554jlUolEomZmZmxsbFMJlMqlcbGxgqFwsTExNjY2NTUVC6X0/FUtGZERARdLqs+IyOj6urqvn37BgUFSaXSjz766FkHbSYnJycLC4tjx461RuOdwIQJEwghcXFxfAcCAK3Cw8MjOzv7448/njRp0htvvPGsanFxcRMnTmwn38MFBQVhYWGJiYl5eXnm5uajR4+2sbFZt24dIWTQoEEffPAB7SSgli1bFhERQQgpKipavXp1fHz8vXv3VCrVgAEDFi1a5OnpSQhJS0tzdnbWPYTemd64cWPmzJl//vmnubn5kiVL5s6d28xTfiH1v4eblZd2FHp5aSM9efLk8ePHBToKCwsLCwuLiop0/9WdFkgoFNI0tcGs1dzcXKVDIGjWIGpoY8hL2wnkpZ2AbhpZXFxcW1tbUlJSXV1NH5Kpn2E+d5OBYymVSolEIpfLTUxM6JzVcrlcIpEolcrGZJu05oue4OjRo+nqRxyGYQQCgVgsnjJlSmBg4IABA0g7ux562SAvBejccnNz6XKDhrXq9zAYVv97uOXnd+k0zMzMzMzM7OzsDFcrKyujOWpBQYFeyvr48ePr169z2azejqampkqlkuao3Au917qF7eSZ7JdcYGBgYGCgXC5v2jpv0GRLliyJjIzkO4qXTkVFRVVVFe1vrKmpKSsrY1mWThJIF1uiFZ6bYeptMnBEmiLKZDI6UbNIJDIzMxMKhaampiqV6lmbGtxLIpHQUbVtj65BRS90aAdpnz59goKCPvzww3b1OBMnPj5+3Lhx9PX169c///zzU6dO0T9b+fn5FhYW+fn5q1atOnr0aG5urlKpdHNzCw8Pf+utt+guWq129erVcXFxOTk5EonExcVl5syZ3t7eQqEwIiLi888/J4S4uLicOXOGEHLixInRo0cTQtRqdUFBgd7Rs7Ky/vWvfyUmJorF4jFjxmzdurWkpCQ4ODg5OVmhUPj4+GzcuFF3mLThwADgpdWYpBTam3/kpXT4LcuSdjY5U7O15hmZmJiYmJjY2toarlZXV/fkyZPifyopKdF9nZOTwxXWX3lFLpdzOapMJqMPMtF7/HK5XCaT0UhkMplcLqd1pFIprUafYoLmmDJlypQpU1qjZQOToS1fvrxVF7bm8dAvat26dXQoC3Bo4ldVVVVRUVFbW0vX3aaDUcvKympqajQajVarpVklV+HJkyeEkNLS0traWt0KNO3Uq/DcGOjXC00ITU1NhUJhg2mk3iYDyWfrfmRthSafQqHQyMho8uTJc+bMGTx4MN9BGeLn58eyrJ+f35EjR2bPnr1ixYpvv/32ypUrLi4uhJCHDx86Ozs/ffr0m2+++a//+q/s7Ox58+Y5Ozv/+uuvdIRYUFDQgQMHDhw44OrqWlpaGhUV5evrm5SU5O7uHhYWFhYWppuNe3l5sSw7ePDgrKys+kcPDQ397LPPvvnmmx9//PGjjz4qLCwUi8WrVq164403du/ePWfOHBMTE25xl+cGBgAAHcg/8lL6h6OykpHJOlV3dnk587xJKFqdQCCg43sbWZ92StTPYOkLjUZTXFxcVFT04MGD4uLiiooKjUZTVlZGL0YbPHqD6Su9pqTXiEZGRgqFgtYkhJiZmRFClEqlQCBQKBRGRkb0IpJ2QYjF4g6xDlKHwOPoEQxcaRHcc4k0o+N6FLlUkEv5uN5CmgoSQuiTjeTvJJMQQnNFQgjtaaRpZ11dHb1XpZt2Pjcw+tsqEolMTEwYhqEPwNNfarlcLhaLzc3NpVIp/d3Xq0B/62kLel8OKpWKYRhaoVU+0I5PoVD07t173rx5kydPbrNkWyQS1b+VoHvvydra2vCS7tTixYvd3d0JIcOGDaM/Zp988kl2dvbu3bvHjBlDCHF0dNy3b1/37t2Dg4PT09MJIadOnXJ0dBw5ciQhRCqVrl+//ujRo007ixkzZtDZ9aZOnRoZGXn8+PHTp0/T/s/Zs2dHRkYmJiZyeenSpUsNBwYAAB3IP/JSutjkwweCnm92qtVT8nIZaxu+g3hBDMPQgcQvuiO9ii0uLq6srKTpq0aj0Wg0paWlZWVllZWV5eXldEYQjUZTUFBQVVVFL4h1+0y4i2DDaP8GdzlLr1Zpxwi96iWEvNAL7kq3MS/gJaQ7M41ubsblckQn0yM6eSBpapZIx6mSv7NE3eM2skdRF9clSHNFQghN+cjf41fJ38kkIcTS0lIikXC70G8D3d8vuote2qn3Cwi8WL58+ebNm9v4oHq3Kpr8fOnQoUP1SuLj4wUCge6qMzY2No6OjhcuXLh///6rr77q5eW1bdu2WbNmTZ8+fciQIUKhsMnrD+t2LL/yyit//fWXbknXrl0zMjIaH1jTYgAAAF78Iy91cCBGRuRqhrCT5aXXroj69eU7iLYiFovFYnETEtoG0f4f+iAZvS6nCQC9fNcdQMj1Een15+Tl5eldxBt48aLoCEDure5Zc9f9lN5gZgM7cnlCgwx8sFxvUoP04mkzz32cj+jkYAY0+H/EZXocLuUzEAD9sdEt0c0k9XZp5C2SxuAyN+5/qn6WyA0EoGNQiU6WyP0I1b+Nwv040Z5G8vc9GvL3Dwx3aHhJtNQ3MC/0xsJotVr6O9jg99utW7deffXVmJgYZ2fn7777ji7v5ObmNnv2bO6R0Rei270sEAiEQqHuYrBCoZBbKboxgTUhAAAA4Ms/8lJjY/L22+T0KSPf96uetUOHU6Ulqb+JMGFK09Crqza7xmpM7kqTZFpft/dMLyPSS3W4zq4Gd7xz586zdtTF9ao1yHB2x3W7tT3agWagguGMmnrWyG0uAePo/bSIxeLXX3/d8OH0HizUq6B7CN0bCnRgOX3NdTaSf94CQEII0Ex0/Rs6kZXu7TxdDMNMnTp16tSp1dXVycnJUVFR/v7+GzZsCA0NpRUEAoHeFyC9j9nagQEAQAei/1U+bhwJCzOqKGfkik7y4NnPx8WVlcx77/EdBzQCl5x06N4GAIDOxN/f/5tvvklJSaHr1FORkZExMTF37twRiUQqlSotLc3e3t7IyGjkyJGurq5yuTwhIYHLS7t06fLgwQNu37y8vJycnOY/efvcwJrZPgBAWyovLx8wYICdnd1Lu8SX/hKaH31E6uqYH3YZ8xJNi2NZ8nWMxNubYDgPAABAE6xdu7Znz57Tp08/fvx4SUlJUVFRbGzsypUro6KiuNxvzpw5ly9f1mq1jx8//uKLL1iWHTFiBNfCqFGjcnNzo6Ojy8vLMzMzQ0JCrKys2iYwAICOgmXZuro6blQgpVAoXF1d+QqpjennpWZmZNEi8uV6yeNH+ps6okN7xVcuCVeu5DsOAACA9iotLY1hmCNHjhBCpFKp3uB8KyurP/74w8/PLygoyNLS0t7e/scffzxy5AhdEp0Qcvr0aXt7+w8++MDc3NzBweHEiRM7d+787LPPuBYiIiICAgLWrFljZWX1ySefLFq0yMbGprCwkGGYJUuW6B09LCwsPT2dYZiffvqptraWYZh169adOXOGYZjTp09XVFQwDENXsXpuYAAAHYiJiUlmZmZiYiLfgfCGqb9QhEZD7B2Is1vVF19WNLhPR1FexngMU/4/fyYmhu9QAAAA/ikuLm7ixIlYrokXNHeNi4vjOxAA4FP7/x5WKBRvvfXWmTNn+A6k5dX/Hm6gU1QmI5s3kQN7xIf2duBlBurqyILZcpZl0FkKAAAAAACtKj8/f/78+d27dxeLxZaWlv7+/pcuXaKbXF1dmb9NmTKFEOLp6cmVFBcXx8fHc2/pPJpRUVEMw1RUVKSkpNDyTv+EQsODdf39yZIlZMkC+dnfO+r5rwmXnkk2ij9M1Gq+QwEAAAAAgM7r4cOHQ4YMiYuL++qrr4qKipKTk4uKipydnc+ePUsIOXPmzKVLl+Ryef/+/WNjYwkhCQkJw4YN27t3L8uyKpXKz8+PZVlfX1+uwYULF7IsK5fLXVxcWJZlWVZ3neoRI0ao1eq0tLS2P9PW88yHSCMiyHvvkcBPFH+c7WCpKcuSzZHS/94m+eYb4uzMdzQAAAAAANCpLV26NDs7e+PGjWPGjFEoFI6Ojvv27WNZNjg4mFbo37//rl27MjIyPvroI5ZlZ8+e7eHh8cEHHzTtcHV1dTRZbbkz4N8z81KBgPzP/xCPEcyUcSYdaECvVsssmCWP2SiJjSWTJvEdDQAAAAAAdFhXr15ldAQFBTVYLT4+XiAQ+Pj4cCU2NjaOjo4XLly4f/8+LRk/fvyyZct+/PFHV1fXwsLCVatWNTkqrj+2yS20Q4b6QqVScuAAWbaMLAySp6UaLQ6vtLCsM1Cfd+fTRCsWy3LvC48fJx4efEcDAAAAAAAdWZ8+fZ7bLanVaktKSgghSqWy/tZbt269+veSlatWrTp58mRqaup3330nEHSG1U9a0HM+DoYha9aQQ4dI2u/idwabxn4pqShnDO/Ci7uZgpBZ8gneJq90Ef7xB5JSAACAjmr//v1vvfUWXbGGYZirV6/yHREAgCHGxsYqlUokElVXV7P1vPPOO1zN5OTkkpKSvn37zp07NyMj47kt6y3c1bk1Kk0fN45c/w8JDWW2REqH9VZ+Okcef0B8+6aQxxy1ro4UFTJ/nhf99zbJpPdMRgxVXr0kjo8nP/9E3niDr6AAAADaNScnJ91hZvwqLy9/88039eJJSUmZNGnSqFGj8vPzb9++zXUyAAC0Z/7+/jU1NSkpKbqFkZGRr732Gjdf0d27d2fMmHHo0KGjR49KpVJfX9/8/HzDzcpksqqqKvrazs5ux44drRF8O9HYOY1kMrJiBQkJId9/zxyOFy+cJ9aZEYpPZubk3VHks6Nk9GgiFPIdDQAAANTT4BJ8LMvW1dXV1f3jEaEDBw6wLBsSEqJQKBQKxb1799o2UgCApli7du3p06enT58eHR399ttv19bWHjhwYOXKlbt27aLru5SXl/v5+W3evLl3796EkIMHD44cOfL9998/efKkkZHRs5odOHDg2bNn7927d//+/Tt37ri5udHyESNGZGRkJCQkODk5tc0JtoEXm2vXzIyEhJCQEKLVkmvXyKNHpKyslQJ7DoGAqFSkRw/Sowd5mfq3AQAAOgkTE5PMzEy9QpqIqrHIGwB0KFZWVn/88cfq1auDgoLu3bunUqkGDBhw5MgRT09PQkhQUFBMTAwhxNfX98qVKzY2Nu7u7oSQ3377TSwWr1q1qk+fPuPGjaNNSaXSyZMn//DDD4SQzZs3z5w508HBwdzcfMuWLQ4ODrROTU1N55uPt4lrwBgbkwEDWjYSAAAAeNnV1tbyHQIAQFOYm5tv2LBhw4YN9TdFR0dHR0frltRPKRtMMu3s7H777bf65Q0WdnSYBgoAAAAaEB8fzy2NkJWVNXHiRJVKpVarfXx89Po5CwsLQ0NDe/bsKRaLzczMRo8enZSURDdFRUUxDFNRUZGSkkKbokPadBt/+vQpV3LkyBFCCJ30yN7eXnd5hoiICEJITU0NV/L++++39YcCAACtA3kpAAAANMDPz49lWV9fX0LIggULFixY8ODBg/379//666+TdJYIz8vLGzJkyJ49e7Zs2VJQUHDu3DmZTObh4fH1118TQhYuXMiyrFwud3FxoaPO6BQguo3XP1xlZSXLstevX2dZ9t133xUIBLdv3w4LCyOEiEQilmWdnZ1379598ODBNv5MAACglSAvBQAA6LREIpFul+O5c+cSEhJ0S2xsbBrTTkBAgLOzs1wu9/T09Pb2Pn/+fEFBAd20dOnSu3fvbt682cfHx9TUtFevXnv27OnSpcv8+fMfPXrU/FMIDQ2tq6vbuHEjV5KSkpKTkzN+/PjmNw4AAO0E8lIAAAAeSCQSQohWq23Vo3BzY1DDhg3z9vbWLcnLy2tMO0OGDOFed+vWjRCSm5tL3x4+fJgQ4u3tzVUwNjb28PCorKz86aefmn8Ko0aN6tu377fffltYWEhL1q9fHxwcbGAGy+eqrKyUSqXNjw0AAFoK8lIAAAAe0ClnuV7Hdk6pVHKvxWIxIYSu76LVaktKSiQSiYmJiW59a2trQkgjk97nWrBggUaj+eqrrwghN2/e/PXXX2fNmtWcBgsKCszNzVskNgAAaBHISwEAAHhgb29PCLly5QrfgTSLsbGxUql8+vRp2T8XjqMjeLlBwkzzlnSbPHmytbV1dHS0VqvdsGHDxx9/bGZm1uTWWJa9du0a/fwBAKCdQF4KAADAA7Va3atXL27e2o6LrrmXkJDAlWi12lOnTkml0nfffZeWyGSyqqoq+trOzm7Hjh0vdAhjY+O5c+c+fvx4w4YNu3fvDgkJaU7A6enppaWlzs7OzWkEAMAwJycnHx8fvqPoSJCXAgAA8MPHx+fQoUMdfWH0tWvX9ujRY8GCBceOHSsrK7t58+aHH3748OHDLVu20NG8hJCBAwfevHnz3r17Z8+evXPnjpub24seZe7cuVKpNCwszNPT84033mhOwAcPHrS1te3Xr19zGgEAgJaFvBQAAIAf06dPz8zMPH78ON/gOZCUAAAQxklEQVSBNCwtLU13QVG6TAvDMJGRkYSQAQMG0K4AGxub8+fPT5o0af78+Wq1eujQoRUVFSdPnpw5cybX1ObNm/v16+fg4DBx4sQtW7Y4ODjorVY6ZcqU+uuXpqWlcS1YWFhMmTKFZdnQ0NDmnJRGo9m1a9e0adOa0wgAALQ4pqPfpgUAAOi43nvvvbt37168eFEkEvEdS3u3a9eumJiY9PT05jQSHh6+devWmzdvWllZtVRgANBBxcXFTZw4sZWyIScnJwsLi2PHjrVG453AhAkTCCFxcXFcCfpLAQAAeLNp06bbt29v376d70A6gO3btzezszQnJ2fDhg3Lly9HUgoA7QodMELduHFjwoQJarWavqXTtufn58+fP7979+5isdjS0tLf3//SpUvc7lqtNjw83N7eXiaTmZubjx079ujRo7W1tYSQiIgI2o6rqyutfOLECVpiYWFR/+jZ2dkTJ040MTFRq9VTp0598uRJVlbW2LFjTUxMunTpMnPmTL1Z7gwH9mJYAAAA4M+SJUtUKtV//vMfvgNpj3bu3Onn51dWVrZt27Y333yzurq6yU1VVVWNGDHC3t6+qqqqBSMEgI5r//79rZcN1V8v+rl8fX0JIcOHD09KSqqoqEhLSxMKhfn5+bm5uba2ttbW1gkJCWVlZVevXh0+fLhEIklNTaU7BgQEKJXKn3/+WaPR5OXlLVy4kBCSlJTEtSyXy11cXHSPNWjQILVaXf/o/v7+6enp5eXl33//PSFk9OjRvr6+Fy9eLCsro7dQP/30U26X5wZmwPjx48ePH69bgrwUAACAT5WVlc7Ozj169Hj8+DHfsbQ7O3fuJISIRKJ+/fpduHChOU3NmTNHoVBcunSppWIDgI6uZfNSoVBouDvQ2tracAs0M0xMTNQr//jjjwkhu3fv5koePnxobGw8aNAg+rZHjx5vv/227i50vnfubePz0oSEBK7E0dGREHL69GmupEePHnZ2do0PzID6eSnG8QIAAPBJIpHEx8ezLOvv719aWsp3OO1LQEAAy7LV1dUZGRkDBw5scjsRERE7duzYs2dP//79WzA8AOjQJBIJIUSr1bZIazU1NbpZVv3+0ry8vMa0M3ToUL2S+Ph4gUCgu+qMjY2No6PjhQsX7t+/Twjx8vJKTU2dNWtWWloaHb5748YNd3f3JpzF4MGDudevvPKKXknXrl1zc3MbH5gBlZWVUqlUtwR5KQAAAM+srKyOHTuWmZnp4uKSlZXFdzidSnV19axZs1asWBEdHT127Fi+wwGAdkStVhNC6AOc7YdcLtd9q9VqS0pK6urqlEolo+PPP/8khNy6dYsQEhMT8/3339+5c8fDw8PU1NTLy+vw4cNNO7qpqSn3WiAQCIVCmUzGlQiFwrq6usYHZkBBQYG5ubluCfJSAAAA/jk6Op47d04kEg0bNiwxMZHvcDqJrKwsLy+vvXv3Hj58ODAwkO9wAKB9sbe3J4RcuXKF70AMMTY2VqlUIpGowQfs33nnHUIIwzBTp049efJkcXExNwBn48aNXCMCgaCqqkq32eLi4jYI7FlYlr127Rr9/P8vyGYGBAAAAC2iW7duv//+u4eHh7e399ixY597sxkM0Gg04eHhvXv3zs3NPXPmDHpKAaA+tVpNn8PkO5Dn8Pf3r6mpSUlJ0S2MjIx87bXXampqCCEqler69euEECMjo5EjR9L5dRMSErjKXbp0efDgAfc2Ly8vJyenDQJ7lvT09NLSUmdnZ91C5KUAAADthUKh2LNnT1JSUnZ2tqOj4/jx448eParRaPiOq8NgWfb8+fOLFy/u3r371q1bIyIiLl++jGdKAeBZfHx8Dh06xLbOEqYtZe3atT179pw+ffrx48dLSkqKiopiY2NXrlwZFRXFrX09Z86cy5cva7Xax48ff/HFFyzLjhgxgmth1KhRubm50dHR5eXlmZmZISEhLbJcVmMCa9DBgwdtbW379eunW8i08/8GAACAl1BNTc2+fftiY2NTU1OFQqGdnV3Xrl11H/sBPU+fPs3Pz7927Vppaamtre20adMCAwOxTikAGPbXX3/16dMnISFhzJgxLduyk5OThYXFsWPHGlM5LS1Nr/NQL0crKipavXp1fHz8vXv3VCrVgAEDFi1a5OnpSbdmZGRs27btt99+y87OlkgkvXr1mjFjxowZMxiGoRVKSkoWLlyYkJBQXFw8aNCgTZs2zZkz58KFC4SQxYsX+/n56R592bJlfn5+Q4YM4UrWrl3r6urq5ubGlSxfvnzFihXPDaxBGo2me/fu8+bNW758uW458lIAAID269GjR8nJyRkZGY8ePdJbzRx0SSQSMzOz3r17Ozs7692DBwAw4L333rt79+7FixcNd/FBSwkPD9+6devNmzf1bh0iLwUAAAAAgJdUZmZmnz591q9fHxQUxHcsnV9OTo6Dg0NERMSnn36qtwl5KQAAAAAAvLyWLl26ffv2s2fP6s0QCy2rurray8srNzf38uXLRkZGeluRlwIAAAAAwMvr6dOnI0aMyMvLO3funKWlJd/hdFqBgYE//PDDmTNnGpyODvPxAgAAAADAy0sikXDLfpaWlvIdTucUERGxY8eOPXv2PGuOdOSlAAAAAADwUrOysjp27FhmZqaLi0tWVhbf4XQq1dXVs2bNWrFiRXR0tIHVpJGXAgAAAADAy87R0fHcuXMikWjYsGGJiYl8h9NJZGVleXl57d279/Dhw4GBgQZqIi8FAAAAAAAg3bp1+/333z08PLy9vceOHXvr1i2+I+rANBpNeHh47969c3Nzz5w5Y6CnlMK8RwAAAAAAAP8nOTl5/vz5169f9/X1nTp1qqenp0wm4zuojoFl2fT09IMHD+7atauqqio8PDw4OLj+7Lv1IS8FAAAAAAD4h5qamn379sXGxqampgqFQjs7u65du5qamvIdV/v19OnT/Pz8a9eulZaW2traTps2LTAw0MrKqpG7Iy8FAAAAAABo2KNHj5KTkzMyMh49elRWVsZ3OO2XRCIxMzPr3bu3s7Nzv379XnR35KUAAAAAAADAJ8x7BAAAAAAAAHxCXgoAAAAAAAB8Ql4KAAAAAAAAfEJeCgAAAAAAAHxCXgoAAG2tvLyc0XH27Nln1Vy0aBFXLSIioi2D5ItCoWAM+vrrr1v2iHFxcQzDGBsbt2yzAAAAjYe8FAAA2ppCoWBZ9uLFi/TtqlWrGqxWWFi4fft2QsjkyZNZlg0LC2u7EJuqvLz8zTff9PHxaU4L9JPx9fVl6xk+fHjLBfu/LC0tuX8BAAB4gbwUAAB4I5VKbW1tjx8/np6eXn/rpk2bunXr1oRmFQqFq6tr48tbEMuydXV1dXV1rXqUloW8FAAAeIe8FAAAeCMQCJYsWUIIqT9Gt7i4eNu2bYsXL+YjrqYzMTHJzMxMTExspfaTk5MDAgJatk3kpQAAwDvkpQAAwKdp06Z17dr16NGjly9f1i3funXrmDFjevbsyVdg7U1QUNCCBQtao2ULCwuGYZCXAgAAj5CXAgAAn4yNjRctWsSy7OrVq7nC8vLyL7/88rPPPqtfv6amZv/+/SNHjrSxsZFKpX379t2yZQs3bjYqKophmIqKipSUFDpLkEgkMlBO5efnz58/v3v37mKx2NLS0t/f/9KlS3RTfHw8N+HQjRs3JkyYoFar6duCggK92HQrP336lBZqtdrw8HB7e3uZTGZubj527NijR4/W1tY250OLiIigR+GGJZ84cYKWWFhY1A8mKytr4sSJKpVKrVb7+PhkZmbqtiYUCs3MzJCXAgAAn+rPqQAAANAGLl68KJfLWZbVaDTW1tYCgeDatWt007p16yZMmMCy7O+//07+nveI+ve//00IWbNmTVFRUX5+/tatWwUCwcKFC3VblsvlLi4u9Y/YYHlubq6tra21tXVCQkJZWdnVq1eHDx8ukUhSU1O5Or6+voSQ4cOHJyUlVVRUpKWlCYXC/Pz8Bs+LVq6srKRvAwIClErlzz//rNFo8vLyFi5cSAhJSkoy/Mk0+Cc7JCTE8OkMGjRIrVbXD8bX1zc1NbW8vPyXX36RSqVDhgzRO6KdnV1ERISBkAAAAFoV+ksBAIBnUqk0NDS0rq5uzZo1hBCNRrNp06Zly5Y9q767u/vSpUvNzMwsLCyCg4M//PDDLVu2lJaWNu3oS5cuzc7O3rhx45gxYxQKhaOj4759+1iWDQ4O1qu5ePFid3d3mUw2bNiwmpoarmfSsFOnTjk6Oo4cOVIqlVpbW69fv75Xr16N2VFvPt558+a98Ln9LSAgwNnZWS6Xe3p6ent7nz9/Xq+z18LCQq1WN7l9AACAZkJeCgAA/Js7d65ard67d+/t27djY2OdnJz69evXYE0fH5+kpCTdkv79+1dXV//1119NO3R8fLxAINBd2cXGxsbR0fHChQv379/XrTl06NAmtO/l5ZWamjpr1qy0tDQ6fPfGjRvu7u5Ni7ZphgwZwr2mUxzn5ubqVhCJRLoDmwEAANoY/ggBAAD/FArFggULPv/88+XLlycnJx85cuRZNUtKSjZs2HD48OH79+8XFxdz5RqNpgnH1Wq1JSUlhBClUll/661bt1599VXurVwub8IhYmJinJ2dv/vuOw8PD0KIm5vb7Nmzx40b96LtREdHN+HolO7ZicViQkjHWskGAAA6PfSXAgBAuxAcHKxUKvfs2dO/f//Bgwc/q9rYsWNXrVo1c+bMmzdv1tXVsSy7adMmQgjLslwdhmEa3Ld+ubGxsUqlEolE1dXV9Z91eeedd5p/XgzDTJ069eTJk8XFxfHx8SzL+vv7b9y4sfktCwSCqqoq3RLdRP2FtMbyMwAAAI2HvBQAANoFpVIZGhqqVCrDwsKeVae2tjYlJcXGxmb+/PmWlpY0z6ysrNSrJpPJuITNzs5ux44dBsr9/f1rampSUlJ0W4iMjHzttddqamqaf14qler69euEECMjo5EjR9JpchMSEprfcpcuXR48eMC9zcvLy8nJaX6zAAAAbQ95KQAAtBfh4eHFxcVvv/32syoIhUJ3d/e8vLz169cXFBRUVlYmJSVt375dr9rAgQNv3rx57969s2fP3rlzx83NzUD52rVre/bsOX369OPHj5eUlBQVFcXGxq5cuTIqKqqlHrmcM2fO5cuXtVrt48ePv/jiC5ZlR4wY0fxmR40alZubGx0dXV5enpmZGRISYmVl1YR2Lly4YGFh4erqisG9AADAmzaY8xcAAECP7rOa7777boN19P5gffnllyzL5ufnz549u1u3bkZGRtbW1p988smSJUtohUGDBtEdr1+/7ubmJpfLu3XrFhMTwzX4rPLCwsLQ0NDXX3/dyMjI0tJy1KhRv/zyC9109uzZxv/dPHz4sG5NurzNpUuXZs+e7eDgQNcvdXJy2rlzJx2B/NxPhhBibW39rJrFxcUBAQFdunSRSqWurq7nz58fNGgQ3Wvx4sV6kS9btkzvI/X29qbtnD9/ngZWW1tr4OwAAABaD8PW+8MPAAAAAAAA0GYwjhcAAAAAAAD4hLwUAAAAAAAA+IS8FAAAAAAAAPiEvBQAAAAAAAD4hLwUAAAAAAAA+IS8FAAAAAAAAPiEvBQAAAAAAAD4hLwUAAAAAAAA+IS8FAAAAAAAAPiEvBQAAAAAAAD4hLwUAAAAAAAA+IS8FAAAAAAAAPiEvBQAAAAAAAD4hLwUAAAAAAAA+IS8FAAAAAAAAPj0/wEPUNu5XWNSkgAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.melt()\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.evaporate()\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.ionize()\n",
"model.show_graph()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### One Machine and multiple models"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# multimodel test\n",
"model1 = Matter()\n",
"model2 = Matter()\n",
"machine = GraphMachine(model=[model1, model2], states=states, transitions=transitions, **extra_args)\n",
"model1.melt()\n",
"model1.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model2.sublimate()\n",
"model2.show_graph()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Show only the current region of interest"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# show only region of interest which is previous state, active state and all reachable states\n",
"model2.show_graph(show_roi=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Example graph from Readme.md"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"hide_input": false
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from transitions.extensions.states import Timeout, Tags, add_state_features\n",
"\n",
"@add_state_features(Timeout, Tags)\n",
"class CustomMachine(GraphMachine):\n",
" pass\n",
"\n",
"\n",
"states = ['new', 'approved', 'ready', 'finished', 'provisioned',\n",
" {'name': 'failed', 'on_enter': 'notify', 'on_exit': 'reset',\n",
" 'tags': ['error', 'urgent'], 'timeout': 10, 'on_timeout': 'shutdown'},\n",
" 'in_iv', 'initializing', 'booting', 'os_ready', {'name': 'testing', 'on_exit': 'create_report'},\n",
" 'provisioning']\n",
"\n",
"transitions = [{'trigger': 'approve', 'source': ['new', 'testing'], 'dest':'approved',\n",
" 'conditions': 'is_valid', 'unless': 'abort_triggered'},\n",
" ['fail', '*', 'failed'],\n",
" ['add_to_iv', ['approved', 'failed'], 'in_iv'],\n",
" ['create', ['failed','in_iv'], 'initializing'],\n",
" ['init', 'in_iv', 'initializing'],\n",
" ['finish', 'approved', 'finished'],\n",
" ['boot', ['booting', 'initializing'], 'booting'],\n",
" ['ready', ['booting', 'initializing'], 'os_ready'],\n",
" ['run_checks', ['failed', 'os_ready'], 'testing'],\n",
" ['provision', ['os_ready', 'failed'], 'provisioning'],\n",
" ['provisioning_done', 'provisioning', 'os_ready']]\n",
"\n",
"\n",
"class CustomModel(Model):\n",
" def is_valid(self):\n",
" return True\n",
" \n",
" def abort_triggered(self):\n",
" return False\n",
"\n",
"\n",
"extra_args['title'] = \"System State\"\n",
"extra_args['initial'] = \"new\"\n",
"model = CustomModel()\n",
"machine = CustomMachine(model=model, states=states, transitions=transitions, **extra_args)\n",
"model.approve()\n",
"model.show_graph()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Custom styling\n",
"\n",
"The `GraphMachine` class uses its attributes `(hierarchical_)machine_attributes` and `style_attributes` to style (sub)graphs, nodes and edges.\n",
"You can edit them and add new entries to `style_attributes` to customized you graph's look."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# thanks to @dan-bar-dov (https://github.com/pytransitions/transitions/issues/367)\n",
"model = Model()\n",
"\n",
"transient_states = ['T1', 'T2', 'T3']\n",
"target_states = ['G1', 'G2']\n",
"fail_states = ['F1', 'F2']\n",
"transitions = [['eventA', 'INITIAL', 'T1'], ['eventB', 'INITIAL', 'T2'], ['eventC', 'INITIAL', 'T3'],\n",
" ['success', ['T1', 'T2'], 'G1'], ['defered', 'T3', 'G2'], ['fallback', ['T1', 'T2'], 'T3'],\n",
" ['error', ['T1', 'T2'], 'F1'], ['error', 'T3', 'F2']]\n",
"\n",
"machine = GraphMachine(model, states=transient_states + target_states + fail_states,\n",
" transitions=transitions, initial='INITIAL', show_conditions=True,\n",
" show_state_attributes=True)\n",
"\n",
"machine.machine_attributes['ratio'] = '0.471'\n",
"machine.style_attributes['node']['fail'] = {'fillcolor': 'brown1'}\n",
"machine.style_attributes['node']['transient'] = {'fillcolor': 'gold'}\n",
"machine.style_attributes['node']['target'] = {'fillcolor': 'chartreuse'}\n",
"model.eventC()\n",
"\n",
"# customize node styling\n",
"for s in transient_states:\n",
" machine.model_graphs[model].set_node_style(s, 'transient')\n",
"for s in target_states:\n",
" machine.model_graphs[model].set_node_style(s, 'target')\n",
"for s in fail_states:\n",
" machine.model_graphs[model].set_node_style(s, 'fail')\n",
"\n",
"# draw the whole graph ...\n",
"model.show_graph()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Enum states\n",
"\n",
"Enum states can also be used with `GraphSupport`. Their labels will be defined by the enum field name."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from enum import Enum, auto, unique\n",
"\n",
"@unique\n",
"class States(Enum):\n",
" \n",
" ONE = auto()\n",
" TWO = auto()\n",
" THREE = auto()\n",
"\n",
"model = Model()\n",
"machine = GraphMachine(model, states=States, auto_transitions=False, ordered_transitions=True, initial=States.THREE)\n",
"model.next_state()\n",
"model.show_graph()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Editing the graph object directly\n",
"\n",
"In case your needed changes are not supported out of the box, you can alter the graph object directly before drawing it.\n",
"The capabilities for direct graph editing depends on the backend you use.\n",
"`pygraphivz` allows to retrieve elements directly.\n",
"This becomes useful, when you for instance want to alter the node labels (maybe because you do not like the ALL CAPS labels generated when using enums)."
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"from transitions.extensions.diagrams import GraphMachine\n",
"\n",
"states = ['A', 'B', 'C', 'D']\n",
"state_translations = {\n",
" 'A': 'Start',\n",
" 'B': 'Error',\n",
" 'C': 'Pending',\n",
" 'D': 'Done'\n",
"}\n",
"\n",
"transitions = [['go', 'A', 'B'], ['process', 'A', 'C'], ['go', 'C', 'D']]\n",
"\n",
"model = Model()\n",
"m = GraphMachine(model, states=states, transitions=transitions, initial='A')\n",
"graph = model.get_graph()\n",
"\n",
"for node in graph.iternodes():\n",
" node.attr['label'] = state_translations[node.attr['label']]\n",
"\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
transitions-0.8.10+3/examples/Frequently asked questions.ipynb 0000644 0002322 0002322 00000107242 14155650047 025000 0 ustar debalance debalance {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Frequently asked questions\n",
"\n",
"* [How do I load/save state machine configurations with json/yaml](#How-do-I-load/save-state-machine-configurations-with-json/yaml)\n",
"* [How to use transitions with django models?](#How-to-use-transitions-with-django-models?)\n",
"* [transitions memory footprint is too large for my Django app and adding models takes too long.](#transitions-memory-footprint-is-too-large-for-my-Django-app-and-adding-models-takes-too-long.) \n",
"* [Is there a during callback which is called when no transition has been successful?](#Is-there-a-'during'-callback-which-is-called-when-no-transition-has-been-successful?)\n",
"* [How to have a dynamic transition destination based on a function's return value?](#How-to-have-a-dynamic-transition-destination-based-on-a-function's-return-value)\n",
"* [Machine.get_triggers should only show valid transitions based on some conditions.](#Machine.get_triggers-should-only-show-valid-transitions-based-on-some-conditions.)\n",
"* [Transitions does not add convencience methods to my model](#Transitions-does-not-add-convencience-methods-to-my-model)\n",
"* [I have several inter-dependent machines/models and experience deadlocks](#I-have-several-inter-dependent-machines/models-and-experience-deadlocks)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How do I load/save state machine configurations with json/yaml\n",
"\n",
"The easiest way to load a configuration is by making sure it is structured just as the `Machine` constructor. Your first level elements should be `name`, `transitions`, `states` and so on. When your yaml/json configuration is loaded, you can add your model programatically and pass the whole object to `Machine`.\n",
"\n",
"#### Loading a JSON configuration"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import Machine\n",
"import json\n",
"\n",
"\n",
"class Model:\n",
"\n",
" def say_hello(self, name):\n",
" print(f\"Hello {name}!\")\n",
"\n",
"\n",
"# import json\n",
"json_config = \"\"\"\n",
"{\n",
" \"name\": \"MyMachine\",\n",
" \"states\": [\n",
" \"A\",\n",
" \"B\",\n",
" { \"name\": \"C\", \"on_enter\": \"say_hello\" }\n",
" ],\n",
" \"transitions\": [\n",
" [\"go\", \"A\", \"B\"],\n",
" {\"trigger\": \"hello\", \"source\": \"*\", \"dest\": \"C\"}\n",
" ],\n",
" \"initial\": \"A\"\n",
"}\n",
"\"\"\"\n",
"\n",
"model = Model()\n",
"\n",
"config = json.loads(json_config)\n",
"config['model'] = model # adding a model to the configuration\n",
"m = Machine(**config) # **config unpacks arguments as kwargs\n",
"assert model.is_A()\n",
"model.go()\n",
"assert model.is_B()\n",
"model.hello(\"world\") # >>> Hello world!\n",
"assert model.state == 'C'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Loading a YAML configuration\n",
"\n",
"This example uses [pyyaml](https://pypi.org/project/PyYAML/)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import Machine\n",
"import yaml\n",
"\n",
"\n",
"class Model:\n",
"\n",
" def say_hello(self, name):\n",
" print(f\"Hello {name}!\")\n",
"\n",
" \n",
"yaml_config = \"\"\"\n",
"---\n",
"\n",
"name: \"MyMachine\"\n",
"\n",
"states:\n",
" - \"A\"\n",
" - \"B\"\n",
" - name: \"C\"\n",
" on_enter: \"say_hello\"\n",
"\n",
"transitions:\n",
" - [\"go\", \"A\", \"B\"]\n",
" - {trigger: \"hello\", source: \"*\", dest: \"C\"}\n",
"\n",
"initial: \"A\"\n",
"\"\"\"\n",
"\n",
"model = Model()\n",
"\n",
"config = yaml.safe_load(yaml_config) \n",
"config['model'] = model # adding a model to the configuration\n",
"m = Machine(**config) # **config unpacks arguments as kwargs\n",
"assert model.is_A()\n",
"model.go()\n",
"assert model.is_B()\n",
"model.hello(\"world\") # >>> Hello world!\n",
"assert model.state == 'C'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Exporting YAML or JSON\n",
"\n",
"A default `Machine` does not keep track of its configuration but `transitions.extensions.markup.MarkupMachine` does. \n",
"`MarkupMachine` cannot just be used to export your configuration but also to visualize or instrospect your configuration conveniently.\n",
"Is is also the foundation for `GraphMachine`. You will see that `MarkupMachine` will always export every attribute even unset values. This makes such exports visually cluttered but easier to automatically process.\n",
"If you plan to use such a configuration with a 'normal' `Machine`, you should remove the `models` attribute from the markup since `Machine` cannot process it properly.\n",
"If you pass the (stored and loaded) configuration to another `MarkupMachine` however, it will attempt to create and initialize models for you."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"#export\n",
"from transitions.extensions.markup import MarkupMachine\n",
"import json\n",
"import yaml\n",
"\n",
"\n",
"class Model:\n",
"\n",
" def say_hello(self, name):\n",
" print(f\"Hello {name}!\")\n",
"\n",
"\n",
"model = Model()\n",
"m = MarkupMachine(model=None, name=\"ExportedMachine\")\n",
"m.add_state('A')\n",
"m.add_state('B')\n",
"m.add_state('C', on_enter='say_hello')\n",
"m.add_transition('go', 'A', 'B')\n",
"m.add_transition(trigger='hello', source='*', dest='C')\n",
"m.initial = 'A'\n",
"m.add_model(model)\n",
"model.go()\n",
"\n",
"print(\"JSON:\")\n",
"print(json.dumps(m.markup, indent=2))\n",
"print('\\nYAML:')\n",
"print(yaml.dump(m.markup))\n",
"\n",
"config2 = json.loads(json.dumps(m.markup)) # simulate saving and loading\n",
"m2 = MarkupMachine(markup=config2)\n",
"model2 = m2.models[0] # get the initialized model\n",
"assert model2.is_B() # the model state was preserved\n",
"model2.hello('again') # >>> Hello again!\n",
"assert model2.state == 'C'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How to use `transitions` with django models?\n",
"\n",
"In [this comment](https://github.com/pytransitions/transitions/issues/146#issuecomment-300277397) **proofit404** provided a nice example about how to use `transitions` and django together:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from django.db import models\n",
"from django.db.models.signals import post_init\n",
"from django.dispatch import receiver\n",
"from django.utils.translation import ugettext_lazy as _\n",
"from transitions import Machine\n",
"\n",
"\n",
"class ModelWithState(models.Model):\n",
" ASLEEP = 'asleep'\n",
" HANGING_OUT = 'hanging out'\n",
" HUNGRY = 'hungry'\n",
" SWEATY = 'sweaty'\n",
" SAVING_THE_WORLD = 'saving the world'\n",
" STATE_TYPES = [\n",
" (ASLEEP, _('asleep')),\n",
" (HANGING_OUT, _('hanging out')),\n",
" (HUNGRY, _('hungry')),\n",
" (SWEATY, _('sweaty')),\n",
" (SAVING_THE_WORLD, _('saving the world')),\n",
" ]\n",
" state = models.CharField(\n",
" _('state'),\n",
" max_length=100,\n",
" choices=STATE_TYPES,\n",
" default=ASLEEP,\n",
" help_text=_('actual state'),\n",
" )\n",
"\n",
"\n",
"@receiver(post_init, sender=ModelWithState)\n",
"def init_state_machine(instance, **kwargs):\n",
"\n",
" states = [state for state, _ in instance.STATE_TYPES]\n",
" machine = instance.machine = Machine(model=instance, states=states, initial=instance.state)\n",
" machine.add_transition('work_out', instance.HANGING_OUT, instance.HUNGRY)\n",
" machine.add_transition('eat', instance.HUNGRY, instance.HANGING_OUT)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### `transitions` memory footprint is too large for my Django app and adding models takes too long.\n",
"\n",
"We analyzed the memory footprint of `transitions` in [this discussion](https://github.com/pytransitions/transitions/issues/146) and could verify that the standard approach is not suitable to handle thousands of models. However, with a static (class) machine and some `__getattribute__` tweaking we can keep the convenience loss minimal:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import Machine\n",
"from functools import partial\n",
"from mock import MagicMock\n",
"\n",
"\n",
"class Model(object):\n",
"\n",
" machine = Machine(model=None, states=['A', 'B', 'C'], initial=None,\n",
" transitions=[\n",
" {'trigger': 'go', 'source': 'A', 'dest': 'B', 'before': 'before'},\n",
" {'trigger': 'check', 'source': 'B', 'dest': 'C', 'conditions': 'is_large'},\n",
" ], finalize_event='finalize')\n",
"\n",
" def __init__(self):\n",
" self.state = 'A'\n",
" self.before = MagicMock()\n",
" self.after = MagicMock()\n",
" self.finalize = MagicMock()\n",
"\n",
" @staticmethod\n",
" def is_large(value=0):\n",
" return value > 9000\n",
"\n",
" def __getattribute__(self, item):\n",
" try:\n",
" return super(Model, self).__getattribute__(item)\n",
" except AttributeError:\n",
" if item in self.machine.events:\n",
" return partial(self.machine.events[item].trigger, self)\n",
" raise\n",
"\n",
"\n",
"model = Model()\n",
"model.go()\n",
"assert model.state == 'B'\n",
"assert model.before.called\n",
"assert model.finalize.called\n",
"model.check()\n",
"assert model.state == 'B'\n",
"model.check(value=500)\n",
"assert model.state == 'B'\n",
"model.check(value=9001)\n",
"assert model.state == 'C'\n",
"assert model.finalize.call_count == 4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You lose `model.is_` convenience functions and the ability to add callbacks such as `Model.on_enter_` automatically. However, the second limitation can be tackled with dynamic resolution in states as pointed out by [mvanderlee](https://github.com/mvanderlee) [here](https://github.com/pytransitions/transitions/issues/146#issuecomment-869049925):"
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"from transitions import State\n",
"import logging\n",
"\n",
"logger = logging.getLogger(__name__)\n",
"\n",
"\n",
"class DynamicState(State):\n",
" \"\"\" Need to dynamically get the on_enter and on_exit callbacks since the\n",
" model can not be registered to the Machine due to Memory limitations\n",
" \"\"\"\n",
"\n",
" def enter(self, event_data):\n",
" \"\"\" Triggered when a state is entered. \"\"\"\n",
" logger.debug(\"%sEntering state %s. Processing callbacks...\", event_data.machine.name, self.name)\n",
" if hasattr(event_data.model, f'on_enter_{self.name}'):\n",
" event_data.machine.callbacks([getattr(event_data.model, f'on_enter_{self.name}')], event_data)\n",
" logger.info(\"%sFinished processing state %s enter callbacks.\", event_data.machine.name, self.name)\n",
"\n",
" def exit(self, event_data):\n",
" \"\"\" Triggered when a state is exited. \"\"\"\n",
" logger.debug(\"%sExiting state %s. Processing callbacks...\", event_data.machine.name, self.name)\n",
" if hasattr(event_data.model, f'on_exit_{self.name}'):\n",
" event_data.machine.callbacks([getattr(event_data.model, f'on_exit_{self.name}')], event_data)\n",
" logger.info(\"%sFinished processing state %s exit callbacks.\", event_data.machine.name, self.name)\n",
"\n",
"\n",
"class DynamicMachine(Machine):\n",
" \"\"\"Required to use DynamicState\"\"\"\n",
" state_cls = DynamicState"
],
"metadata": {
"collapsed": false,
"pycharm": {
"name": "#%%\n"
}
}
},
{
"cell_type": "markdown",
"source": [
"### Is there a 'during' callback which is called when no transition has been successful?\n",
"\n",
"Currently, `transitions` has no such callback. This example from the issue discussed [here](https://github.com/pytransitions/transitions/issues/342) might give you a basic idea about how to extend `Machine` with such a feature:"
],
"metadata": {
"collapsed": false,
"pycharm": {
"name": "#%% md\n"
}
}
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions.core import Machine, State, Event, EventData, listify\n",
"\n",
"\n",
"class DuringState(State):\n",
"\n",
" # add `on_during` to the dynamic callback methods\n",
" # this way on_during_ can be recognized by `Machine`\n",
" dynamic_methods = State.dynamic_methods + ['on_during']\n",
" \n",
" # parse 'during' and remove the keyword before passing the rest along to state\n",
" def __init__(self, *args, **kwargs):\n",
" during = kwargs.pop('during', [])\n",
" self.on_during = listify(during)\n",
" super(DuringState, self).__init__(*args, **kwargs)\n",
"\n",
" def during(self, event_data):\n",
" for handle in self.on_during:\n",
" event_data.machine.callback(handle, event_data)\n",
"\n",
"\n",
"class DuringEvent(Event):\n",
"\n",
" def _trigger(self, model, *args, **kwargs):\n",
" # a successful transition returns `res=True` if res is False, we know that\n",
" # no transition has been executed\n",
" res = super(DuringEvent, self)._trigger(model, *args, **kwargs)\n",
" if res is False:\n",
" state = self.machine.get_state(model.state)\n",
" event_data = EventData(state, self, self.machine, model, args=args, kwargs=kwargs)\n",
" event_data.result = res\n",
" state.during(event_data)\n",
" return res\n",
"\n",
"\n",
"class DuringMachine(Machine):\n",
" # we need to override the state and event classes used by `Machine`\n",
" state_cls = DuringState\n",
" event_cls = DuringEvent\n",
"\n",
"\n",
"class Model:\n",
"\n",
" def on_during_A(self):\n",
" print(\"Dynamically assigned callback\")\n",
"\n",
" def another_callback(self):\n",
" print(\"Explicitly assigned callback\")\n",
"\n",
"\n",
"model = Model()\n",
"machine = DuringMachine(model=model, states=[{'name': 'A', 'during': 'another_callback'}, 'B'],\n",
" transitions=[['go', 'B', 'A']], initial='A', ignore_invalid_triggers=True)\n",
"machine.add_transition('test', source='A', dest='A', conditions=lambda: False)\n",
"\n",
"assert not model.go()\n",
"assert not model.test()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How to have a dynamic transition destination based on a function's return value\n",
"\n",
"This has been a feature request [here](https://github.com/pytransitions/transitions/issues/269). We'd encourage to write a wrapper which converts a condensed statement into individual condition-based transitions. However, a less expressive version could look like this:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import Machine, Transition\n",
"from six import string_types\n",
"\n",
"class DependingTransition(Transition):\n",
"\n",
" def __init__(self, source, dest, conditions=None, unless=None, before=None,\n",
" after=None, prepare=None, **kwargs):\n",
"\n",
" self._result = self._dest = None\n",
" super(DependingTransition, self).__init__(source, dest, conditions, unless, before, after, prepare)\n",
" if isinstance(dest, dict):\n",
" try:\n",
" self._func = kwargs.pop('depends_on')\n",
" except KeyError:\n",
" raise AttributeError(\"A multi-destination transition requires a 'depends_on'\")\n",
" else:\n",
" # use base version in case transition does not need special handling\n",
" self.execute = super(DependingTransition, self).execute\n",
"\n",
" def execute(self, event_data):\n",
" func = getattr(event_data.model, self._func) if isinstance(self._func, string_types) \\\n",
" else self._func\n",
" self._result = func(*event_data.args, **event_data.kwargs)\n",
" super(DependingTransition, self).execute(event_data)\n",
"\n",
" @property\n",
" def dest(self):\n",
" return self._dest[self._result] if self._result is not None else self._dest\n",
"\n",
" @dest.setter\n",
" def dest(self, value):\n",
" self._dest = value\n",
"\n",
"# subclass Machine to use DependingTransition instead of standard Transition\n",
"class DependingMachine(Machine):\n",
" transition_cls = DependingTransition\n",
" \n",
"\n",
"def func(value):\n",
" return value\n",
"\n",
"m = DependingMachine(states=['A', 'B', 'C', 'D'], initial='A')\n",
"# define a dynamic transition with a 'depends_on' function which will return the required value\n",
"m.add_transition(trigger='shuffle', source='A', dest=({1: 'B', 2: 'C', 3: 'D'}), depends_on=func)\n",
"m.shuffle(value=2) # func returns 2 which makes the transition dest to be 'C'\n",
"assert m.is_C()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that this solution has some drawbacks. For instance, the generated graph might not include all possible outcomes."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### `Machine.get_triggers` should only show valid transitions based on some conditions.\n",
"\n",
"This has been requested [here](https://github.com/pytransitions/transitions/issues/256). `Machine.get_triggers` is usually quite naive and only checks for theoretically possible transitions. If you need more sophisticated peeking, this `PeekMachine._can_trigger` might be a solution:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import Machine, EventData\n",
"from transitions.core import listify\n",
"from functools import partial\n",
"\n",
"\n",
"class Model(object):\n",
"\n",
" def fails(self, condition=False):\n",
" return False\n",
"\n",
" def success(self, condition=False):\n",
" return True\n",
"\n",
" # condition is passed by EventData\n",
" def depends_on(self, condition=False):\n",
" return condition\n",
"\n",
" def is_state_B(self, condition=False):\n",
" return self.state == 'B'\n",
"\n",
"\n",
"class PeekMachine(Machine):\n",
"\n",
" def _can_trigger(self, model, *args, **kwargs):\n",
" # We can omit the first two arguments state and event since they are only needed for\n",
" # actual state transitions. We do have to pass the machine (self) and the model as well as\n",
" # args and kwargs meant for the callbacks.\n",
" e = EventData(None, None, self, model, args, kwargs)\n",
"\n",
" return [trigger_name for trigger_name in self.get_triggers(model.state)\n",
" if any(all(c.check(e) for c in t.conditions)\n",
" for t in self.events[trigger_name].transitions[model.state])]\n",
"\n",
" # override Machine.add_model to assign 'can_trigger' to the model\n",
" def add_model(self, model, initial=None):\n",
" for mod in listify(model):\n",
" mod = self if mod is self.self_literal else mod\n",
" if mod not in self.models:\n",
" setattr(mod, 'can_trigger', partial(self._can_trigger, mod))\n",
" super(PeekMachine, self).add_model(mod, initial)\n",
"\n",
"states = ['A', 'B', 'C', 'D']\n",
"transitions = [\n",
" dict(trigger='go_A', source='*', dest='A', conditions=['depends_on']), # only available when condition=True is passed\n",
" dict(trigger='go_B', source='*', dest='B', conditions=['success']), # always available\n",
" dict(trigger='go_C', source='*', dest='C', conditions=['fails']), # never available\n",
" dict(trigger='go_D', source='*', dest='D', conditions=['is_state_B']), # only available in state B\n",
" dict(trigger='reset', source='D', dest='A', conditions=['success', 'depends_on']), # only available in state D when condition=True is passed\n",
" dict(trigger='forwards', source='A', dest='D', conditions=['success', 'fails']), # never available\n",
" dict(trigger='forwards', source='D', dest='D', unless=['depends_on'])\n",
"]\n",
"\n",
"model = Model()\n",
"machine = PeekMachine(model, states=states, transitions=transitions, initial='A', auto_transitions=False)\n",
"assert model.can_trigger() == ['go_B']\n",
"assert set(model.can_trigger(condition=True)) == set(['go_A', 'go_B'])\n",
"model.go_B(condition=True)\n",
"assert set(model.can_trigger()) == set(['go_B', 'go_D'])\n",
"model.go_D()\n",
"assert model.can_trigger() == ['go_B', 'forwards']\n",
"assert set(model.can_trigger(condition=True)) == set(['go_A', 'go_B', 'reset'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Transitions does not add convencience methods to my model\n",
"\n",
"There is a high chance that your model *already contained* a `trigger` method or methods with the same name as your even trigger. In this case, `transitions` will not add convenience methods to not accidentaly break your model and only emit a warning. If you defined these methods on purpose and *want* them to be overrided or maybe even call *both* -- the trigger event AND your predefined method, you can extend/override `Machine._checked_assignment` which is always called when something needs to be added to a model:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import State, Machine\n",
"\n",
"class StateMachineModel:\n",
"\n",
" state = None\n",
"\n",
" def __init__(self):\n",
" pass\n",
"\n",
" def transition_one(self):\n",
" print('transitioning states...')\n",
"\n",
" def transition_two(self):\n",
" print('transitioning states...')\n",
"\n",
"\n",
"class OverrideMachine(Machine):\n",
"\n",
" def _checked_assignment(self, model, name, func):\n",
" setattr(model, name, func)\n",
"\n",
"\n",
"class CallingMachine(Machine):\n",
"\n",
" def _checked_assignment(self, model, name, func):\n",
" if hasattr(model, name):\n",
" predefined_func = getattr(model, name)\n",
" def nested_func(*args, **kwargs):\n",
" predefined_func()\n",
" func(*args, **kwargs)\n",
" setattr(model, name, nested_func)\n",
" else:\n",
" setattr(model, name, func)\n",
"\n",
"\n",
"states = [State(name='A'), State(name='B'), State(name='C'), State(name='D')]\n",
"transitions = [\n",
" {'trigger': 'transition_one', 'source': 'A', 'dest': 'B'},\n",
" {'trigger': 'transition_two', 'source': 'B', 'dest': 'C'},\n",
" {'trigger': 'transition_three', 'source': 'C', 'dest': 'D'}\n",
"]\n",
"state_machine_model = StateMachineModel()\n",
"\n",
"print('OverrideMachine ...')\n",
"state_machine = OverrideMachine(model=state_machine_model, states=states, transitions=transitions, initial=states[0])\n",
"print('state_machine_model (current state): %s' % state_machine_model.state)\n",
"state_machine_model.transition_one()\n",
"print('state_machine_model (current state): %s' % state_machine_model.state)\n",
"state_machine_model.transition_two()\n",
"print('state_machine_model (current state): %s' % state_machine_model.state)\n",
"\n",
"print('\\nCallingMachine ...')\n",
"state_machine_model = StateMachineModel()\n",
"state_machine = CallingMachine(model=state_machine_model, states=states, transitions=transitions, initial=states[0])\n",
"print('state_machine_model (current state): %s' % state_machine_model.state)\n",
"state_machine_model.transition_one()\n",
"print('state_machine_model (current state): %s' % state_machine_model.state)\n",
"state_machine_model.transition_two()\n",
"print('state_machine_model (current state): %s' % state_machine_model.state)"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"### I have several inter-dependent machines/models and experience deadlocks\n",
"\n",
"A common use case involves multiple machines where one machine should react to events emitted by the other(s).\n",
"Sometimes this involves 'waiting' as in 'all machines are triggered at the same time but machine 1 needs to wait until\n",
"machine 2 is ready'. `Machine` will process callbacks sequentially. Thus, if your callbacks contain passages like this\n",
"\n",
"```python\n",
"class Model:\n",
" def on_enter_state(self):\n",
" while not event:\n",
" time.sleep(1)\n",
"```\n",
"\n",
"it is very likely that `event` will never happen because the callback will block the event processing forever.\n",
"\n",
"Bad news first: there is no one-fits-all-solution for this kind of problem.\n",
"Now the good news: There is a solution that fits many use cases. An event bus! We consider transitions to be events that\n",
"can be emitted by user input, system events or other machines.\n",
"\n",
"The event bus approach decouples the need of individual machines to know each other. They communicate via events.\n",
"Thus, we can model quite complex inter-dependent behaviour without threading or asynchronous processing.\n",
"Furthermore, other components do not need to know which machine processes which event, they can broadcast the message on\n",
"the bus and rest assured that whoever is interested in the event will get it.\n",
"The challenge is to wrap one's head around the concept of modelling transitions as events rather than actions to be conducted.\n",
"\n",
"Since we expect events to be emitted in callbacks, and we also expect that not every event bus member will be able to\n",
"process every event sent across the bus, we pass `queued=True` (every machine processes one event at a time) and\n",
"`ignore_invalid_triggers=True` (when the event cannot be triggered from the current state or is unknown, ignore it)."
]
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"from transitions import Machine\n",
"import logging\n",
"\n",
"\n",
"class EventBus:\n",
"\n",
" def __init__(self):\n",
" self.members = []\n",
"\n",
" def add_member(self, member):\n",
" \"\"\"Member can be a model or a machine acting as a model\"\"\"\n",
" # We decorate each member with an 'emit' function to fire events.\n",
" # EventBus will then broadcast that event to ALL members, including the one that triggered the event.\n",
" # Furthermore, we can pass a payload in case there is data that needs to be sent with an event.\n",
" setattr(member, 'emit', self.broadcast)\n",
" self.members.append(member)\n",
"\n",
" def broadcast(self, event, payload=None):\n",
" for member in self.members:\n",
" member.trigger(event, payload)\n",
"\n",
"\n",
"# Our machines can either be off or started\n",
"states = ['off', 'started']\n",
"\n",
"\n",
"class Machine1(Machine):\n",
"\n",
" # this machine can only boot once.\n",
" transitions = [['boot', 'off', 'started']]\n",
"\n",
" def __init__(self):\n",
" # we pass 'ignore_invalid_triggers' since a machine on an event bus might get events it cannot process\n",
" # right now and we do not want to throw an exception every time that happens.\n",
" # Furthermore, we will set 'queued=True' to process events sequentially instead of nested.\n",
" super(Machine1, self).__init__(states=states, transitions=self.transitions,\n",
" ignore_invalid_triggers=True, initial='off', queued=True)\n",
"\n",
" def on_enter_started(self, payload=None):\n",
" print(\"Starting successful\")\n",
" # We emit out start event and attach ourselves as payload just in case\n",
" self.emit(\"Machine1Started\", self)\n",
"\n",
"\n",
"class Machine2(Machine):\n",
"\n",
" # This machine can also reboot (boot from every state) but only when the 'ready' flag has been set.\n",
" # 'ready' is set once the event 'Machine1Started' has been processed (before the transition is from 'off' to 'on'\n",
" # is actually executed). Furthermore, we will also boot the machine when we catch that event.\n",
" transitions = [{'trigger': 'boot', 'source': '*', 'dest': 'started', 'conditions': 'ready'},\n",
" {'trigger': 'Machine1Started', 'source': 'off', 'dest': 'started', 'before': 'on_machine1_started'}]\n",
"\n",
" def __init__(self):\n",
" super(Machine2, self).__init__(states=states, transitions=self.transitions,\n",
" ignore_invalid_triggers=True, initial='off', queued=True)\n",
" self._ready = False\n",
"\n",
" # Callbacks also work with properties. Passing the string 'ready' will evaluate this property\n",
" @property\n",
" def ready(self):\n",
" return self._ready\n",
"\n",
" @ready.setter\n",
" def ready(self, value):\n",
" self._ready = value\n",
"\n",
" def on_machine1_started(self, payload=None):\n",
" self.ready = True\n",
" print(\"I am ready now!\")\n",
"\n",
" def on_enter_started(self, payload=None):\n",
" print(\"Booting successful\")\n",
"\n",
"\n",
"logging.basicConfig(level=logging.DEBUG)\n",
"bus = EventBus()\n",
"machine1 = Machine1()\n",
"machine2 = Machine2()\n",
"bus.add_member(machine2)\n",
"bus.add_member(machine1)\n",
"bus.broadcast('boot')\n",
"# what will happen:\n",
"# - bus will broadcast 'boot' event to machine2\n",
"# - machine2 will attempt to boot but fail and return since ready is set to false\n",
"# - bus will broadcast 'boot' event to machine1\n",
"# - machine1 will boot and emit the 'Machine1Started'\n",
"# - bus will broadcast 'Machine1Started' to machine2\n",
"# - machine2 will handle the event, boot and return\n",
"# - bus will broadcast 'Machine1Started' to machine1\n",
"# - machine1 will add that event to its event queue\n",
"# - bus broadcast of 'Machine1Started' returns\n",
"# - machine1 is done with handling 'boot' and process the next event in the event queue\n",
"# - machine1 cannot handle 'Machine1Started' and will ignore it\n",
"# - bus broadcast of 'boot' returns\n",
"assert machine1.state == machine2.state\n",
"bus.broadcast('boot')\n",
"# broadcast 'boot' event to all members:\n",
"# - machine2 will reboot\n",
"# - machine1 won't do anything"
],
"metadata": {
"collapsed": false,
"pycharm": {
"name": "#%%\n"
}
}
},
{
"cell_type": "markdown",
"source": [
"If you consider this too much boilerplate and you don't mind some dependencies and less generalization\n",
"you can of course go the leaner asynchronous or threaded route and process your callbacks in parallel.\n",
"Having `while event` loops as mentioned above in `async` callbacks is not uncommon. You should consider, however, that\n",
"the execution order of callbacks as described in the README is kept for `AsyncMachine` as well.\n",
"All callbacks of one stage (e.g. `prepare`) must return before callbacks of the next state (e.g. `conditions`) are triggered."
],
"metadata": {
"collapsed": false,
"pycharm": {
"name": "#%% md\n"
}
}
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": [
"from transitions.extensions.asyncio import AsyncMachine\n",
"import asyncio\n",
"\n",
"states = ['off', 'started']\n",
"\n",
"\n",
"class Machine1(AsyncMachine):\n",
"\n",
" transitions = [{'trigger': 'boot', 'source': 'off', 'dest': 'started', 'before': 'heavy_processing'}]\n",
"\n",
" def __init__(self):\n",
" super(Machine1, self).__init__(states=states, transitions=self.transitions, initial='off')\n",
"\n",
" async def heavy_processing(self):\n",
" # we need to do some heavy lifting before we can proceed with booting\n",
" await asyncio.sleep(0.5)\n",
" print(\"Processing done!\")\n",
"\n",
"\n",
"class Machine2(AsyncMachine):\n",
"\n",
" transitions = [['boot', 'off', 'started']]\n",
"\n",
" def __init__(self, dependency):\n",
" super(Machine2, self).__init__(states=states, transitions=self.transitions, initial='off')\n",
" self.dependency = dependency\n",
"\n",
" async def on_enter_started(self):\n",
" while not self.dependency.is_started():\n",
" print(\"Waiting for dependency to be ready...\")\n",
" await asyncio.sleep(0.1)\n",
" print(\"Machine2 up and running\")\n",
"\n",
"\n",
"machine1 = Machine1()\n",
"machine2 = Machine2(machine1)\n",
"asyncio.get_event_loop().run_until_complete(asyncio.gather(machine1.boot(), machine2.boot()))\n",
"assert machine1.state == machine2.state"
],
"metadata": {
"collapsed": false,
"pycharm": {
"name": "#%%\n"
}
}
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.3 64-bit ('transitions': conda)",
"language": "python",
"name": "python38364bittransitionsconda9f9fdeb4313741768b0dccf7fd8ce480"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
} transitions-0.8.10+3/examples/Playground.ipynb 0000644 0002322 0002322 00000021321 14155650047 021674 0 ustar debalance debalance {
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Playground\n",
"\n",
"Make sure to read the [documentation](https://github.com/pytransitions/transitions#table-of-contents) first.\n",
"\n",
"* [Rescue those kittens!](#Rescue-those-kittens!)\n",
"* [Too much coffee with my hierarchical state machines!](#Too-much-coffee-with-my-hierarchical-state-machines!)\n",
"* [Very asynchronous dancing](#Very-asynchronous-dancing)\n",
"* [Fun with graphs](#Fun-with-graphs)\n",
"\n",
"\n",
"## Rescue those kittens!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions import Machine\n",
"import random\n",
"\n",
"class NarcolepticSuperhero(object):\n",
"\n",
" # Define some states. Most of the time, narcoleptic superheroes are just like\n",
" # everyone else. Except for...\n",
" states = ['asleep', 'hanging out', 'hungry', 'sweaty', 'saving the world']\n",
" # A more compact version of the quickstart transitions\n",
" transitions = [['wakeup', 'asleep', 'hanging out'],\n",
" ['work_out', 'hanging out', 'hungry'],\n",
" ['eat', 'hungry', 'hanging out'],\n",
" {'trigger': 'distress_call', 'source': '*', 'dest': 'saving the world', 'before': 'change_into_super_secret_costume'},\n",
" {'trigger': 'complete_mission', 'source': 'saving the world', 'dest': 'sweaty', 'after': 'update_journal'},\n",
" {'trigger': 'clean_up', 'source': 'sweaty', 'dest': 'asleep', 'conditions': 'is_exhausted'},\n",
" ['clean_up', 'sweaty', 'hanging out'],\n",
" ['nap', '*', 'asleep']]\n",
"\n",
"\n",
" def __init__(self, name):\n",
"\n",
" # No anonymous superheroes on my watch! Every narcoleptic superhero gets\n",
" # a name. Any name at all. SleepyMan. SlumberGirl. You get the idea.\n",
" self.name = name\n",
" self.kittens_rescued = 0 # What have we accomplished today?\n",
"\n",
" # Initialize the state machine\n",
" self.machine = Machine(model=self, states=NarcolepticSuperhero.states,\n",
" transitions=NarcolepticSuperhero.transitions, initial='asleep')\n",
"\n",
" def update_journal(self):\n",
" \"\"\" Dear Diary, today I saved Mr. Whiskers. Again. \"\"\"\n",
" self.kittens_rescued += 1\n",
"\n",
" @property\n",
" def is_exhausted(self):\n",
" \"\"\" Basically a coin toss. \"\"\"\n",
" return random.random() < 0.5\n",
"\n",
" def change_into_super_secret_costume(self):\n",
" print(\"Beauty, eh?\")\n",
" \n",
" def yell(self):\n",
" print(f\"I am {self.name} and I am {self.state}!\")\n",
" \n",
"batman = NarcolepticSuperhero(\"Batman\")\n",
"batman.wakeup()\n",
"assert batman.state == 'hanging out'\n",
"batman.yell()\n",
"# the rest is up to you ..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Too much coffee with my hierarchical state machines!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions.extensions import HierarchicalMachine as Machine\n",
"\n",
"states = ['standing', 'walking', {'name': 'caffeinated', 'children':['dithering', 'running']}]\n",
"transitions = [\n",
" ['walk', 'standing', 'walking'],\n",
" ['stop', 'walking', 'standing'],\n",
" ['drink', '*', 'caffeinated'],\n",
" ['walk', ['caffeinated', 'caffeinated_dithering'], 'caffeinated_running'],\n",
" ['relax', 'caffeinated', 'standing']\n",
"]\n",
"\n",
"machine = Machine(states=states, transitions=transitions, initial='standing', ignore_invalid_triggers=True)\n",
"\n",
"assert machine.walk() # Walking now\n",
"# I fancy a coffee right now ..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Very asynchronous dancing"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"scrolled": false
},
"outputs": [],
"source": [
"from transitions.extensions.asyncio import AsyncMachine\n",
"import asyncio\n",
"\n",
"class Dancer:\n",
" \n",
" states = ['start', 'left_food_left', 'left', 'right_food_right']\n",
" \n",
" def __init__(self, name, beat):\n",
" self.my_name = name\n",
" self.my_beat = beat\n",
" self.moves_done = 0\n",
" \n",
" async def on_enter_start(self):\n",
" self.moves_done += 1\n",
" \n",
" async def wait(self):\n",
" print(f'{self.my_name} stepped {self.state}')\n",
" await asyncio.sleep(self.my_beat)\n",
"\n",
" async def dance(self):\n",
" while self.moves_done < 5:\n",
" await self.step()\n",
" \n",
"dancer1 = Dancer('Tick', 1)\n",
"dancer2 = Dancer('Tock', 1.1)\n",
"\n",
"m = AsyncMachine(model=[dancer1, dancer2], states=Dancer.states, initial='start', after_state_change='wait')\n",
"m.add_ordered_transitions(trigger='step')\n",
"\n",
"# it starts okay but becomes quite a mess\n",
"_ = await asyncio.gather(dancer1.dance(), dancer2.dance()) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fun with graphs\n",
"\n",
"This requires `pygraphviz` or `graphviz`"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from transitions.extensions.states import Timeout, Tags, add_state_features\n",
"from transitions.extensions.diagrams import GraphMachine\n",
"\n",
"import io\n",
"from IPython.display import Image, display, display_png\n",
"\n",
"\n",
"@add_state_features(Timeout, Tags)\n",
"class CustomMachine(GraphMachine):\n",
" pass\n",
"\n",
"\n",
"states = ['new', 'approved', 'ready', 'finished', 'provisioned',\n",
" {'name': 'failed', 'on_enter': 'notify', 'on_exit': 'reset',\n",
" 'tags': ['error', 'urgent'], 'timeout': 10, 'on_timeout': 'shutdown'},\n",
" 'in_iv', 'initializing', 'booting', 'os_ready', {'name': 'testing', 'on_exit': 'create_report'},\n",
" 'provisioning']\n",
"\n",
"transitions = [{'trigger': 'approve', 'source': ['new', 'testing'], 'dest':'approved',\n",
" 'conditions': 'is_valid', 'unless': 'abort_triggered'},\n",
" ['fail', '*', 'failed'],\n",
" ['add_to_iv', ['approved', 'failed'], 'in_iv'],\n",
" ['create', ['failed','in_iv'], 'initializing'],\n",
" ['init', 'in_iv', 'initializing'],\n",
" ['finish', 'approved', 'finished'],\n",
" ['boot', ['booting', 'initializing'], 'booting'],\n",
" ['ready', ['booting', 'initializing'], 'os_ready'],\n",
" ['run_checks', ['failed', 'os_ready'], 'testing'],\n",
" ['provision', ['os_ready', 'failed'], 'provisioning'],\n",
" ['provisioning_done', 'provisioning', 'os_ready']]\n",
"\n",
"\n",
"class Model:\n",
" \n",
" # graph object is created by the machine\n",
" def show_graph(self, **kwargs):\n",
" stream = io.BytesIO()\n",
" self.get_graph(**kwargs).draw(stream, prog='dot', format='png')\n",
" display(Image(stream.getvalue()))\n",
" \n",
" def is_valid(self):\n",
" return True\n",
" \n",
" def abort_triggered(self):\n",
" return False\n",
"\n",
"model = Model()\n",
"machine = CustomMachine(model=model, states=states, transitions=transitions, initial='new', title='System State',\n",
" show_conditions=True, show_state_attributes=True)\n",
"model.approve()\n",
"model.show_graph()\n",
"\n",
"# Your turn! What happens next? "
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3.8.3 64-bit ('transitions': conda)",
"language": "python",
"name": "python38364bittransitionsconda9f9fdeb4313741768b0dccf7fd8ce480"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
transitions-0.8.10+3/examples/Graph MIxin Demo Nested.ipynb 0000644 0002322 0002322 00002216132 14155650047 023676 0 ustar debalance debalance {
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"hide_input": false
},
"outputs": [],
"source": [
"import os, sys, inspect, io\n",
"\n",
"cmd_folder = os.path.realpath(\n",
" os.path.dirname(\n",
" os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0])))\n",
"\n",
"if cmd_folder not in sys.path:\n",
" sys.path.insert(0, cmd_folder)\n",
"\n",
"from transitions.extensions.states import Timeout, Tags, add_state_features\n",
"from transitions.extensions.factory import HierarchicalGraphMachine as Machine\n",
"from IPython.display import Image, display, display_png\n",
"\n",
"@add_state_features(Timeout, Tags)\n",
"class CustomStateMachine(Machine):\n",
" pass\n",
"\n",
"class Matter(object):\n",
" def do_x(self):\n",
" pass\n",
" def do_y(self):\n",
" pass\n",
" def do_z(self):\n",
" pass\n",
" def is_hot(self):\n",
" return True\n",
" def is_too_hot(self):\n",
" return False\n",
" def show_graph(self, **kwargs):\n",
" stream = io.BytesIO()\n",
" self.get_graph(**kwargs).draw(stream, prog='dot', format='png')\n",
" display(Image(stream.getvalue()))\n",
"\n",
"extra_args = dict(auto_transitions=False, initial='standing', title='Mood Matrix',\n",
" show_conditions=True, show_state_attributes=True)"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"hide_input": false
},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"states = [{'name': 'caffeinated', 'on_enter': 'do_x',\n",
" 'children':['dithering', 'running'], 'transitions': [['drink', 'dithering', '=']]},\n",
" {'name': 'standing', 'on_enter': ['do_x', 'do_y'], 'on_exit': 'do_z'},\n",
" {'name': 'walking', 'tags': ['accepted', 'pending'], 'timeout': 5, 'on_timeout': 'do_z'},\n",
" \n",
" ]\n",
"transitions = [\n",
" ['walk', 'standing', 'walking'],\n",
" ['go', 'standing', 'walking'],\n",
" ['stop', 'walking', 'standing'],\n",
" {'trigger': 'drink', 'source': '*', 'dest': 'caffeinated_dithering',\n",
" 'conditions':'is_hot', 'unless': 'is_too_hot'},\n",
" ['walk', 'caffeinated_dithering', 'caffeinated_running'],\n",
" ['relax', 'caffeinated', 'standing'],\n",
" ['sip', 'standing', 'caffeinated']\n",
"]\n",
"\n",
"model = Matter()\n",
"machine = CustomStateMachine(model=model, states=states, transitions=transitions, **extra_args)\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.walk()\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.drink()\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.walk()\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAABLcAAAKCCAYAAAAjnzsqAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1jV5f/H8ec5bFBEFBDUBPfGnLlyoubEmZWS6dcRP5XKlVrm3jtzNNXShpamOXKbmvubmttwiwqCgqAyz+8Pkm/EEBQ5Iq/HdXF1nftzf+77fR8S9H3u+/0xmEwmEyIiIiIiIiIiIjnPNaO5IxAREREREREREXlcSm6JiIiIiIiIiEiOpeSWiIiIiIiIiIjkWEpuiYiIiIiIiIhIjqXkloiIiIiIiIiI5FhKbomIiIiIiIiISI6l5JaIiIiIiIiIiORYSm6JiIiIiIiIiEiOpeSWiIiIiIiIiIjkWEpuiYiIiIiIiIhIjqXkloiIiIiIiIiI5FhKbomIiIiIiIiISI6l5JaIiIiIiIiIiORYSm6JiIiIiIiIiEiOZWnuAESeVevWweLF5o5C5PnQqhX06GHuKERERERE5Hmk5JZIGs6ehbW/QJNmMeYORSRH27vbisKFDeYOQ0REREREnlNKbomkI39+E/MXR5k7DJEcrWMLR8DC3GGIiIiIiMhzSjW3REREREREREQkx1JyS0REREREREREciwlt0REREREREREJMdScktERERERERERHIsJbdEJEutX7OGlg0aUNbDA09nZzydnTlz6hQhwcG8268fNcuVS2p/p29fc4drdmt/+inp/Sjt7m7ucERERERERHIcJbdEJMv89+BB/u+tt6jfsCGHz51j5+HDuHt4ADCwd2/27trF0h9/5MTly/QdMCDT40dFRdGwenV6du2a1aGbTZsOHbgYFkbdBg3MHYqIiIiIiEiOZGnuAETk+fHLqlWYTCbe6tcPBwcHHLy82Hv8OGGhoezdtQu///yHsuXLA/D+6NGYTKbMTWAykZCQQEJCwlOIPm3lixShfKVKrNywIVvnFRERERERkUdTcktEskzQtWsA5Hd2TtZ+PZV2g8GAwWDI1PgOefLw23//+4RRioiIiIiIyPNExxJFJMvEx8en257ZZJaIiIiIiIjIoyi5JZIL3Q4LY9zIkbxctSqlChXipQoVeKN9e1YuX86DBw+S+sXFxfHLqlV0a9+e6mXKUMbdneZ16/LlwoXJjgZuWrcOT2dnNq9fD0AZd/ekIumezs60bdIEgNlTpiS17du9O+n+sFu3GP3++9T19qakmxtVS5Wir58fJ//8M8UcD7+io6NTbb96+TL9e/akkqcnVUqUoGfXrly6cCHZ+jO6rk/nzcPT2Zl79+5xaP/+pDlKuLgkGy8j8T8UeO4cvbt1o2KxYpQrXJjOLVtycN++TH8PRUREREREJJGSWyK5TEhwMG2bNGHNjz/y0aRJHPnrL37ZsYOX6tZlcP/+LP/qq6S+O7dupX+vXtR5+WW27t/P3uPHee3NNxn/wQdMHj06qV+zVq24GBaGT8uWAJy5fp0LoaGcv3WLwJAQVm/eDMDAIUP4KziYv4KDqVW3LgDBN2/SpkkTflm1ivHTp3P0/Hm+W7uWO7dv075ZM/578GCqc6Q195gRI+j59tvsP3mSeV9+ye+//cbA//wn2T0ZXVef/v25GBaGvb091WvV4mJYGBfDwggMCUnqk9H4AS6eP0/7Zs34848/WLBkCYfOnmXc9OnMnTYtRQJOREREREREMkbJLZFcZsrYsVy5dImPJk+mSfPmOOTJQ0EXFwYMHkyDv3dY/dNL9erh/+675HNywrlAAXr06UO7Tp34ctEiIu/eTXMeg8GA0WjEwsICozHxR43RaMTS0hJLS8ukI4pTxo7l2pUrfDhhAo18fHBwcKB02bLM++ILTMBHw4Zlan1du3enao0a2NvbU69BAxo3a8bRP/4gLDQ0S9b1b5mJf9q4cUSEh/PR5MnUb9gQBwcHypYvz/RPPiH45s1MrVNEREREREQSKbklksv8+ssvADRq2jTFtSUrVtDz7beTXjdp3pzv1qxJ0a9cxYrExcZy9vTpJ45n07p1GI1GmjRvnqzdxdWV0mXL8ueRI1wPCsrweN5VqyZ77V64MADBN24ktWXlujIT/46tWwF4uXHjZH3dChWieIkSGZ5TRERERERE/kdPSxTJRWKio7kbEYGNjQ0OefI8sv/diAg+++QTfv3lF64HBRERHp7s+v1797IkHoCKxYql2e9iYCDuHh4ZGjOvo2Oy19bW1gDJamll1boyE3+BAgWIioxMfO8dHFL0KeDiwvnAwAzNKyIiIiIiIv+j5JZILmJtY0NeR0fuRkQQFRn5yARXr9de48DevXw0aRLtOnYkf4ECGAwGvlywgLEjR2LKgngc8+XjXlQUp4OCsLTMnh9JmV1XWk95zGz8DnnyEBUZSVRUVIoE153bt59kSSIiIiIiIrmWjiWK5DLNW7cGYPvfRd7/qWWDBowdORKA+Ph4Du3fj4urK2/17YtzwYJJSZ5/PlHxSbVo3Zq4uDgO79+f4tqCOXOoXakScXFxWTbf46zL1t6e2JiYpNeNatRg+ZIlmY7/4VHQnX8fT3woLDSU8+fOPfniREREREREciElt0RymWGjRlG0WDHGjhjBtk2biIqM5HpQEB8MHkzwjRv85++aWxYWFrxUrx4hwcEs+vhjwkJDefDgAXt37eKbfzxRMSviKeblxZABA9ixZQt3IyK4c/s2yxcvZu7UqYwcNy5Ld3Q9zroqVq7M+cBArl+7xn8PHuTKpUvUrF070/EP+fBDnPLnZ+zw4ezasYOoqCjOnTnDO337Yp+BY6IiIiIiIiKSksFkMj3pySKR59KsWTB1mol9J+6YO5QsdzssjI9nzGDz+vVcDwrC2dmZWnXr8t7w4Xj9o7B5WGgo0ydMYPvmzYQEB+Pk5ERDHx9cXF1ZMHs2AJWqVGHAoEH06d49xTyrNm1i2MCBBJ47R3x8fNITFH1atmTh3zufIPFI3rwZM9i0fj1B167hmC8fFSpVou/AgdRr0ABILNz+7zl8O3fmzd69ad+sWbL2/oMGMXjkSDydnZO1N27WjC+/+y7D61q7bRsA5//6i/cDAjh+9Cj58ufH/5136N6rV6bif+hCYCCTRo/m999+Iy42ljLlyhEwbBhfLFjAnp07AXi1WzemzJ2bge9kztCxhSP1alvw91srIiIiIiKSla4puSWShuc5uSWSnZTcEhERERGRp+iajiWKiIiIiIiIiEiOpeSWiIiIiIiIiIjkWEpuiYiIiIiIiIhIjqXkloiIiIiIiIiI5FiW5g5ARERERJ4R0dFw6BD8+SeEhEBUlLkjer5YWoKTE5QsCdWrQ5Ei5o5IRETkuaDkloiIiEhuZjLB5s3w2WewYUNiQsvJCQoVAgcHc0f3fImLg9u34epVSEiAypWhWzfo2RMKFDB3dCIiIjmWklsiIiIiudUff0BAAOzaBS+/DDNmgI8PFC9u7sieb5GRsHcv/PwzTJiQ+DVqFAwYAFZW5o5OREQkx1HNLRExq/JFitDplVfMHYaISO7y4AH4+0ONGhAfDwcPws6d0LevElvZIU+exCTivHlw7RoMHAgffJC4k2vfPnNHJyIikuMouSUiIiKSm9y8CY0awfffw5IlsHt3Yv0nMQ8HBxg7Fk6eBC+vxO/N8uXmjkpERCRH0bFEERERkdzi9Glo0QKsrROPxZUunfF7HzyAoKDEmlHyaHZ2iXW03Nwy1t/TE375BYYNS6zD9ddfiUcVRURE5JGU3BKRRwq7dYu506ezecMGbt64gaOjIzVq1yZgyBDKV6oEwKZ16+jTvXvSPbuPHGHy6NHs3LYNCwsLqtaowUeTJlHMywuAT+fNY+Lff2k/tH8/ns7OAFhYWBAYEvJEc287cIAZEyaw57ffuPP3P8L+e+4czirWKyK5WUgItGwJHh6wdm3GCpjv3w8//IBp/XoM584lHmGUzHHOD/XrQztf6Nw58UhiWoxGmDYNSpWCfv3A1TXxvyIiIpIug8lkMpk7CJFn0axZMHWaiX0n7pg7FLMKvnmT9s2aEf3gAdPmzaNmnTpcu3KFD4cM4cihQ3y7Zg1Va9RI6t+7Wzc2r1+PT8uWvB0QQNkKFfjvwYP857XXKFOuHD9v3Zps/PJFilC+UiVWbtiQZXPXqluXd4cNw7taNc6cPEnHFi04ePo0zgUK8Fq7dpw6fpyvvv+eF3UMJ1t0bOFIvdoWzJ5t7khEcrGYGGjWDC5fTqzp5Oqafv9du+C9d+HQYeI9XIku70WspwfxBfNjsrfNnphzOENsLMa797C8Foz1mUtYn74A1jYwaBAMHQr29ukPMG5c4nHF9esT63OJiIhIWq5p55aIpGvK2LFcu3KFOZ9+SqO//3JdumxZ5n3xBXW9vflo2DDWbtuW4r6u3bsnJZ7qNWhA42bNWL9mDWGhoRneQfW4c78dEMBL9eoBUKVatWQ7wRISEjCZTCivLyK5yvDhcPQo/P57+omta9dg8GD4/ntiypcgarAfscWLZF+czxt3iCldjHuNamCMuo/t7j9wmDYVwxefw8xZiTu50vLBB3D2LHTtCmfOQMGC2Re3iIhIDqOC8iK5yJlTp/B0dk72NWro0HTv2bRuHUajkSbNmydrd3F1pXTZsvx55AjXg4JS3OddtWqy1+6FCwMQfONGhuPNqrn/6fu1azl6/nyyHV8iIs+1U6fg448Tj7uVK5d2v99/hypViN++hfB+nbjzf12U2MpCCQ523Gteh9BRfXjwQkHo+ir8nz/ExaV+g8EACxYk1u768MPsDVZERCSH0c4tkVykTLlyXAwLy3D/mOho7kZEAFCxWLE0+10MDMTdwyNZW15Hx2Svra2tgcSdU097bnsHhwzNISKSK7z3HlSsCG+9lXafH36AN/2IKVmU8J7tMNnaZF98uUyCowMR3VoRXbEkjl9+ieHMWVi5EpycUnbOkwcmT4Y334RevfRUSxERkTQouSUiabK2scExXz7uRUVxOigIS8us/5FhMBjMNreIyHNv3z7YuBF27AALi9T7fP89vPYa95rUIrJ9o8QdQ/LURVcpw23nfDgt+hFjy5awfTvYpJJUfOMNmDsXpkyBFSuyP1AREZEcQMcSRSRdLVq3Ji4ujsP796e4tmDOHGpXqkRcWkcqMsDW3p7YmJik141q1GD5kiXZMreIyHPv88+hShVo0CD164cPw1s9uNe4JpEdGiuxlc3iXijE7QFdMR07Cn5+kFo9SIMBBg6En39OfOKliIiIpKDkloika9ioURTz8mLIgAHs2LKFuxER3Ll9m+WLFzN36lRGjhv3RLuqKlauzPnAQK5fu8Z/Dx7kyqVL1Kxd+6nN/Vq7dlQpUYI/Dh167JhFRHKEhAT45ZfEguSpCQ6Gli2JKfUCke0bZ29s2WD1oZO4+U/EzX8iRQdOMXc4aYovVIDwnu3gxx9h5szUO7Vvn7jzbv367A1OREQkh1ByS0TSVcDFhZ+3bKFZy5aMGjqUF0uVonGtWmxYu5bPli+nta8vAH8cOoSnszOb//6Ldxl3d6ZPmACAp7MzC+bMAaBlgwb0/Mc/tD6aNIlyFSrQpFYt/q9nTz6aNImSpUs/8dyezs6pric+Lk5PSxSR3OHsWbh5E5o0Sf36iOEkxMcQ3qMtGJ+/HVu+1ctzc/4I6pfxTHEtKjqGlz5aQLf5P2R/YKmIKedFVKv6MOpDuHo1ZQcHB6hVC/bsyf7gREREcgAVsRGRR3LKn58Pxo/ng/Hj0+zzYvXqaRarT6+IffGSJflh3bqnNve/pTeXiMhz5cQJMBoTi8n/23//C18t5u5b7TDZWmfZlF7vTKNiUTfWDvLLsjGfBpMJEkwmEp6hDzruNa2F7YETWAwZAt9+m7KDtzdo17GIiEiqlNwSEREReR6FhCQ+gc/WNuW1wYOJLfkC0VXLZX9cz4A8ttYcGOtv7jCSMVlaENm+IfkWfg9DhkDVqsk7uLqq5paIiEgadCxRRERE5Hn04AHY2aVsP30aduwgqtlL8PydRszRoiuVIr6wGyyYn/KivT3cu5f9QYmIiOQA2rklIiIi8jxK68jdypUkODkSU84rQ8PExMUza+Me1hw+xdWwcGytLKlRogjd675I04olsTAamL9lP2N+2grAgcCruPlPBMDCaCBo3nAA4hISWPfHab7Zc5RTQcFE3I/GyyU/3epWoVfD6hj/flLjhqNn6bFoZdL8h8b9H+NWb2P7yfMYjUZqeBVmfGcfPF3yJ4vz3I1Qxq/ezp6zl4hLSKBy0UKM9G2YYj3/Hv/ynKHYWFlmybyx8fGU9XBhcMv6LNp2gF1nLgLweh1vZnVrlaH3+37NCuT58SdYuCixiLyIiIg8knZuiYiIiOQmmzYRU84TDBnbtvX+97/y+faDTOzSjDPT32P3qL6UciuA38IV7P/rMgD+TWtxc/4I7K2tqFmiCDfnj+Dm/BFJiS2A7SfO0+eL1dQrU4zdo/pyZEJ/utd7kVErtzBu1bakfq94l+bm/BG0qJz4cJEPVmymT6OaHJ00kM96+bLrzEX6frk6WYwXQm7TatoSjl6+zhe9O3BiSgBTXmvOzPW7uXjrdrK+/x4/K+c9OfUd5vq15tPtBzl5LRhrSwtuzh+R4cQWQEzFEnD7dmJdNBEREckQJbdEREREcguTCY4eJfaFQhm+Zdfpi5Rxd6FBOS9srSxxcXTgow5NKOGa+lNp01OndDECmtfByd4W5zz2/KdhdTrUqMBn2w9y90F0qvd0q1uF6sULY29txctlvfCpWJIjl64TFvm/I3oTf95B+P0HjO/sQ4NyXjjYWFPOw5U5fm24GR6Z6TifZN4y7i4s7NmOezGxjzVvnFsBTLa2cPToY90vIiKSGym5JSI53tqffsLT2RlPZ2dKu7ubOxwRkWdXVBRERBDv7JThWxpXKM7B81cZtGw9hy9cIz4h8bjj76P7Uad0sQyP41OpJKveeSNFe4UibsTGJ3Am6Faq91Uplvznukd+RwBu/CNpte1kIACNyhdP1rdQvjyUcC2Q4Rizat4Ceewp5fZ482IwkFDQCa5efbz7RUREciHV3BKRbOXr44NzgQJ8+d13WTZmmw4daNOhA2+0b8/BffuybFwRkefO3bsAmGytM3zL5FdbUN2rCN/vO0bHOcsBeKlkUfzqvUjLKmUyPE7E/WgWbN3P+iNnuH77LuH3HyS7fj829Z1OjnY2yV5bWybWoUr4u6ZYTFw8kQ9isLGyxMEm5boK5rUnMDg0w3Fm1bz57FN5SmUGmWytISLise8XERHJbZTcEhEREcktEhIS/5vBelsPu3auVZHOtSoSG5/A72cvMX/LPt769EfGdGxCvya1/tE37XG7L/iBfX9dYXxnHzrUqICzgz0GA3y67QAfrtyCKa0C+I9gbWlBHltrIh/EEBUdkyLRdOfe/cca90nnvXX38Z9saDIY0n4ggIiIiKSgY4kiIiIikqZSg2Zw7kbizicrCyMNynmxpF9nDAbYfDwwWV87ayti4uKTXtcZvZCvd/9BfIKJA4FXcXV0oHejGhTIY5+UX7sfG/fEMTapUAKAbSfPJ2sPi7zHXzfDnnj8zM4bHBH1WLvFRERE5PEouSUiIiIi6Rr67QZOXgsmJi6eW3ejmLdpLyYT1C+TvOZW5aJunA8OI+h2BIfOX+PSrTu8VLIoFkYDdUoXIzgiik827yMs8h4PYuPYc/YSS3Y9+VMBR7RtiJODHR+u2MzOUxeIio7h7PVb+C9ek+qRwayS2ryng0IIWLoWV8c8T21eERERSU7HEkUkxwk8d47JY8awd9cu4uPiqOjtzdBRo9LsfzssjHkzZrB5wwaCrl3D3t6eF6tXp9/AgdSuXz9Tc3d65RUO7d+f9Nq3c2dmL1rEG+3bs2fnzqT2Yxcu4JgvX+YXJyLyjFn9bncW7zpMny9WczUsHBsrS0q4OjPzjZa8XqdKsr7jOvswaNl66o5ZhJODHeO7+FCqUEEAPuvly6S1O/l8xyEmrdmBk4MdTcqXoGONCsz9dS+d536L9wuFmPRqc1pOW5I05gsBU3mnRV2Gt22Am//EpPYmE7/Ap2JJvvHvgqdLftYPeZNxq7bR67OfiI2Pp6yHC4Nb1WfR1gPsOnMRN/+JvF7Hm2aVStFj0cpk43esWZFeDao98bxxCQlULOLGSN+GTP1lF6GRj380UURERDJOyS0RyVEunj9P+2bNsLe3Z8GSJVStUYMrly4x4cMPuXThQor+IcHBdGjenPv37jFl7lxq1alDSHAwU8aO5XVfXybNnk3X7t0zPP/KDRs4dfw4HVu0oFjx4kycNQuAr777ji6tW9Pr7bdp06FDlq1XRMTcKhRxZdprr2Sob0m3Avz8Xuo/U53z2Kc5zsh2jZK9vjl/RKr90moHKOHqzOK+nVK0+1QsmeFxsnLe4PBInPPYpXmfiIiIZB0dSxSRp6aEiwuezs7Jvo4cPsy2TZtStFcvk7Enbk0bN46I8HA+mjyZ+g0b4uDgQNny5Zn+yScE37yZov+UsWO5cukSH02aRJPmzcmTNy9eJUow99NPcXVzY/SwYdwKCcnUuspVrMi0Tz7h1PHjvPf225hMJoa/9x51GzRQYktEJBcJjoiizOCZxMYnJGu/EhrOxZDb1C/taZ7AREREchklt0TkqQkMCeFiWFiyryrVqtG4WbMU7YfOnMnQmDu2bgXg5caNk7W7FSpE8RIlUvT/9ZdfAGjcrFmydmsbG+o2aMCDBw/Y+feYmdGqXTv6DxrExrVr6fTKK9wJC2PQiLQ/2RcRkefTnXsPGLJ8PUG3I7gfE8sfF4Po/cUq8tjZ8F7LeuYOT0REJFdQcktEcoyY6GiiIiOxsbHBwcEhxfUCLi4p+t+NiEjsnydlYd+Cf/cPCQ5+rHgGjRhBlWrVOHzgAC3btcNo1I9UEZHcxNXRgZUBrxN+P5q2M7+m1OCZdF+4guKuzvw6tAfFCjqZO0QREZFcQTW3RCTHsP47SRUVGUlUVFSKBNed27dT9M/r6MjdiAiiIiNTJLgeHkd0cXV9rHj27d7N3YgIypYvz4eDB1O+YkXKVaz4WGOJiEjOVL+MJ/XLeJo7DBERkVxN2wxEJEdp1LQpQIqjhGGhoZw/dy5F/+atWwOwbdOmZO0x0dHs2bkTW1tbGjRpkuk4rly6xNCBA1m4dCmfL1+OrZ0d/3njDcJu3cr0WCIiIiIiIvL4lNwSkRxlyIcf4pQ/P2OHD2fXjh1ERUVx7swZ3unbF/tUjh4OGzWKosWKMWb4cLb++itRkZFcCAxkYJ8+BN+8yUeTJycdT8yoqKgoenfrxqiJEylVpgxFXniBBYsXc/PGDfr16EFcbGxWLVdEREREREQeQcktEclRinl5sWrTJipXrcrbb75JtVKlGOzvT48+fShbvjwx0dF4OjszbOBAIPHI4ZqtW2nbqROj338f7xIlaNukCfeioli2ahWv+fllav5RQ4dSoWhRTp84Qe833uDMqVOEhYbyaps2xMXGcuD33ynp5sbH06c/jeWLiIiIiIjIv6jmlohkq9WbNz/xGF4lSvDp11+naP/3ExEfyu/szKgJExg1YcITzz126lTGTp2aov1iWNgTjy0iIo/m9c40KhZ1Y+2gzH04ISIiIs8v7dwSEREREREREZEcS8ktERERERERERHJsXQsUUQE8HR2fmSfd4YN451hw7IhGhGRnC008h4z1+9m47Fz3Ay/S147W14qWZRBLetRsYgbABuOnqXHopVJ9xwa93+MW72N7SfPYzQaqeFVmPGdffB0yQ/A/C37GfNT4pNyDwRexc1/IgAWRgNB84Y/0dx7PurLlLW/8duZi9yJug/Aqanv4JzH/im+SyIiIpJVlNwSEUE1s0REssrN8EhaTltCdFwcs7u1pnapolwNC+f9736l5bQl/BTwBtWLF+YV79LcnD+CNxeuZOOxs3ywYjMDmtVmdvfWHDp/le4LVtD3y9X8OuwtAPyb1sK/aa10a2497txDlm9gSKv6zPVrzamgEFpPX5I0ZofZyzhxLZjl/l2o5lU4295HERERyTgdSxQRERGRLDPh5+1cDQtnbMemNK1YAgcba8q4u7CoV3tMJhMjfvg11fu61a1C9eKFsbe24uWyXvhULMmRS9cJi7z31Ofu36w2dUoXw87aiqqeHgTNG560a8tkMoHJhMmU+fdCREREsod2bomIiIhIqk4HhdBg/GfJ2no2qMakV5unec+Go2cxGgz4VCqZrN3V0YGy7i4cvXyDoDt38XDKm+x6lWLuyV575HcE4EZ4ZIaPBz7u3FU9PdIcc9W73TI0t4iIiJiPklsiIiIikqqyHi7cnD8iw/1j4uKJuB8NQMn3ZqTZ70JwWIoEk6OdTbLX1pYWACRkcMvUk8xtb22VoTlERETk2aTkloiIiIhkCWtLC/LZ2RIVHcOluUOxNGZ9BQyDwWC2uUVEROTZpN/6IiIiIpJlWr1YhriEBA4EXk1x7eNNe3lx5DziEhIee3w7ayti4uKTXtcZvZCvd/+RLXOLiIjIs0nJLRERERHJMiPbNcTTJT/vfP0LW08EEnE/mjtR91m66w9mrN/N6A5NnmhXVeWibpwPDiPodgSHzl/j0q07vFSy6FObu8PsZZQZMovDF649dswiIiLydOlYooiIiIhkmYJ5Hfh1aA9mbfyd4d//StDtCBztbKlU1I2l/TrxclkvAA5fuEbLaUuS7nshYCrvtKjL8LYNcPOfmNTeZOIX+FQsyTf+XQAY19mHQcvWU3fMIpwc7BjfxYdShQo+8dxAqvXF4hMS9LREERGRZ5ySWyIiIiKSpZwc7BjTsQljOjZJs081r8JpFqtPr4h9SbcC/Pxe96c297+lN5eIiIg8G3QsUUREREREREREciwlt0REREREREREJMdScktERERERERERHIsJbdERERERERERCTHUnJLRERERERERERyLCW3RERERLLB9OnTMRgMGAwGihQpYu5wngurD53EzX8ibv4TKTpwirnDERERETNRcjoZaVIAACAASURBVEtEREQkGwwePBiTyYS3t7e5QzGLV6Yuptv8H7J0TN/q5bk5fwT1y3hm6bgiIiKSsyi5JSIiIiIiIiIiOZaSWyIiIiIiIiIikmMpuSUiIiIiIiIiIjmWklsiIiIiqVi9enVSAXiDwcCZM2fo0qULBQoUSGq7desWACEhIQwcOBBPT0+sra1xcXGhQ4cOHDlyJENzxcXF8f333+Pj40OhQoWws7OjUqVKzJkzh4SEhKR+9erVSxZTt27dAGjatGmy9jt37mT9G/IMOHcjlDcXrqTkezPwfGcabWd8zf7AK2n2vx11n1Ert1Bz1HyKDJhM6UEzeW3ed+w5eynTc7eZsTSpeL2b/0T8F68BoNOc5cnaw+8/eOz1iYiIyONRcktEREQkFb6+vphMJtq1awdA37598ff358qVK+zbtw8LCwsArl+/To0aNfjhhx+YP38+YWFh7Nixg7CwMGrXrs3evXsfOdfGjRvp2rUrjRs35tSpU1y5coU+ffrw3nvvMWzYsKR+u3fv5siRIzg4OODt7c2iRYsAWLduHbVq1eLbb7/FZDLh5OT0FN4R87oQcptW05Zw9PJ1vujdgRNTApjyWnNmrt/NxVu3U/QPjoii2eSv+OnQCSZ0bsapae+yYVgP7Kyt6DhnGcv2ZCzx+NDaQX5sG/Ef7K2tqFDElemvvwLA8v97laqeHizq6cvN+SPIZ2ebJesVERGRjLM0dwAiIiIiOcGwYcNo2LAhALVq1SIuLg6AHj16cOnSJZYtW0bLli0BqFChAt999x2enp4MGDCAQ4cOPXL8hg0bMnz48KTXAwYM4MCBA8yZM4cPP/wQR0dHALy9vfnqq6/o0qULfn5+rFy5kr59+9KkSRO6du2axat+PB79JxGfYEr1mpv/xGSvXRwdOD454JFjTvx5B+H3HzCzW0salPMCoJyHK3P82lDjw09S9J+wejuXQ++wqKcvPpVKApDX1oaFPX2p8eEnjPhhE80qlcLF0SHD66pQxJU5fq3p/fkq+i9ewxe9OzJ4+Xrql/XEt3r5DI8jIiIiWUvJLREREZEMqFmzZqrtq1evxmg00rp162TthQoVokKFChw+fJirV69SpEiRNMdu3bp1ivshMZH1zTffcOLECWrXrp3U3rlzZ0aOHMmECROoV68ezs7OfPnll4+5sqwXNG94irZXpi6mQB57vvHv8lhjbjsZCECj8sWTtRfKl4cSrgUIDA5N1r7+6BkAmlYsmazd2tKC+mU9WbH/ONtPnadLrUqZiqNt1XKcaBHM7I17aDNjKU4OtszunvJ7JyIiItlHyS0RERGRDHBwSLnDJzo6mvDwcADy5cuX5r3nzp1LN7kVHh7OjBkzWLVqFVevXk1RM+vevXsp7hk3bhxbtmzh999/Z8mSJRiNz2+1iZi4eCIfxGBjZYmDjXWK6wXz2idLbsXExRNxPxobK0vy2Kbs75I38XsZHBH1WPG836YBv52+wMHzV/n4zTYYDYbHGkdERESyxvP7tyARERGRp8zGxgYnJycsLS2JjY3FZDKl+tWoUaN0x2nTpg3jxo2jd+/enD17loSEBEwmE7NmzQLAZEp5xG/Hjh2Eh4dTqVIl/P39OXr06FNZ47PA2tKCPLbWRMfGERUdk+L6nXv3U/R3tLMhOjaOyAcp+4fcTUxquWbiSOI//X7uEncfRFPOw5Vh327kxNXgxxpHREREsoaSWyIiIiJPoEOHDsTFxbFnz54U16ZMmcILL7yQVJ8rNfHx8ezZs4dChQoxcOBAXFxcMPy9E+j+/fup3nPhwgV69erFjz/+yJo1a7Czs6Ndu3aEhIRkzaKeQU0qlABg28nzydrDIu/x182wFP1bepcBYMvxv5K1x8TFs+v0RWytLGlUrniK+x7lcugd3vl6HV/27sjXb3fG1toKv4UrCI1MubtOREREsoeSWyIiIiJPYNKkSZQoUYKePXuyYcMGwsPDCQsLY9GiRYwdO5bp06djaZl2JQgLCwsaNmzIjRs3mDZtGrdu3eL+/fts376dhQsXpugfGRmJr68vs2fPpnz58nh6erJy5UqCgoLo1KkTsbGxT3O5ZjOibUOcHOz4cMVmdp66QFR0DGev38J/8ZpUjyqO9G3ECwWc+GDlZjb/+ReRD2IIDA6j35eruRkRyYQuzTJVTB4gKjqGNxeuZHxnH0q7F6RogXx80bsDN8Pv0uvTn4iNT8iq5YqIiEgmKLklIikkJCSwY8sWxo0cSf+ePRn9/vtsXLs23Z0HIlklOjqaVatW0b9/f3OHIrncvn37MBgM/PzzzwDY2dkl7aj6J1dXVw4cOICvry/9+/fHxcWFsmXL8tNPP/Hzzz/TpUtiAfXp06djMBg4evQo165dw2Aw8MEHHwDw/fff07dvXz7++GM8PDzw8vJi6dKlvP766wD4+PhQokR1+vXrT968eTl27Bjt2rXj+PHj3Lp1i4YNGxIbG8tvv/2GtbU148ePz6Z3Kft4uuRn/ZA3qVLMnV6f/UT5obMZsHQtvRpWp5yHCzFx8bj5T+Tdb9YBiUcON73/Fu2rV2DED5soO2QmLaZ8xb2YWFYOfJ1udatkav7h3/9K8Xenc/JaMH4LV3A6KISwyHu0n/UNsfEJ7P3rMkUGTGbWhpQ7+EREROTpMphSK+IgIsyaBVOnmdh34s6jOz9HrgcF0fuNNzh+9ChW1tbExsRgZWVFXFwcxby8+GzZMkqVKWPuMCUH6djCkXq1LZg9O+0+8fHxbN++nWXLlrFy5UoiIyNxc3Pjxo0b2ReoyDOsVCn46y+ws4OOHeH118HHB9LZEJb4i2zGDLh69X9t165BkSLcHuRHbIm0C9yLeeWftQyrVu0Tv4cPpfb9FBEREYBr2rklIkkePHjAa23bcvrkSQBiYxKL8D4sknzl0iVebd2asFu3zBmmPEf27dtHQEAAhQoVwsfHh2XLlhEZGQmkXkBbJLd6+Mfh/n347jto2RIKFgR/f9i163/XRURERHIjJbdEJMnyr77iyuXLxKVRryU+Pp6IiAjmp7cFR+QRTp48yejRo/H09KR27dosWLCAW38nTJ/XWkEiWenhCfHwcPjiC3j5ZXBzg4AA2L3bvLGJiIiImEN6m9lFJJdZv2YNCfHx6faJi43ll9Wr+eA5rOciT8/du1eYM+cnli1bxsGDB7G2tibmHzsDReTx/P3HiJAQWLgQ5s6FEiWgWzd4PSY/pc0bXo7g5j/xkX0Gt6rPkFb1syEaEREReRxKbolIksuXLmXoKFjwjRskJCRgNGrzp6TNZDKxYvlyTp/4lsMH9gL/+3/rYWIrPSEhUVhbl3iKEYrkHI/43AH4X6IrMBDGjIExQGWr+fRbAH36gIXFUw0xx7o5f4S5QxAREZEnpOSWiCSxtbXNUD8rKysltuSRDAYDLdu2Zd6MPFhZORAevg2DwYDJlIDJlPDI+21sLGnUqE82RCry7Nu9G+7efXQ/gyHxy2QCz/wR9EzYRNeubZXYEhERkeeaklsikuTFatUIunqVuIcFXVJhMBgoX6lSNkYlOVmevHlxce1O+3Y9GDUqjF9++YUvv/yS3377DUtLy3SPJDo62rB+/bBsjFbk2VWyZPrJLUvLxFpcpUpBz57QvTt4fD8LZiyB/POyL9BstvrQSfp+uRoAa0sLrszVzwwREZHcSFsvRCTJG2+9lW5i66E3e/fOhmjkeePs7Iyfnx87duzg8uXLTJs2jRo1agBgbW1t5uhEni2RkZGUKlWK1q1bp9nn4R+bEiVg5Eg4cybxa9gw8PDIpkAz4ZWpi+k2/4csHdO3enluzh9B/TKeWTquiIiI5CxKbolIkpp16tBnwAAMBgMGgyHFdaPRSOv27WnXqZMZopPnSZEiRQgICODAgQOcOHGCoUOHUrRoUeB/ia6M1H8TeV6ZTCYSEhJISEh+hNfKKvG/bm7wzjtw5Aj89ReMHg2lVT1eREREciklt0QkmRFjxjB93jzc3N2Tted3duaDceOY8+mnqSa+RB5X+fLlGTduHJcvX2bfvn28/fbbFCxYEAsVCZJcLG/evAQGBrJ+/Xog8dihkxP07g27dsH16zBlCnh7mzlQERERkWeAam6JSAodX3uNjq+9xok//6RVgwZMnDWLrt27q4i8PHW1atWiVq1azJgxg4MHD5o7HJFnxpIlUK1aYpJLRERERJLTX5FEJE1eJUoAUMjdXYktyVYWFha89NJL5g5DJMtFR0czYcIEfvjhBy5fvoytrS1169ald+/etGrVCgsLC1avXk379u2T7rl//z61atkyffp0hgwZAkDhwoVZtWoV77//PgcOHCA+Pp5atWoxfvx46tata67lPXXnboQyfvV29py9RFxCApWLFmKkb8M0+9+Ous+sDXvYeOwsQbcjsLe2ppqXB/2b1aZu6WIZnjf8/gNKD5qZrO39Ng1495W6xCUkULj/5KT21i+W5YveHTK9NhEREXl8+teqiKTp4bGwf9d8ERGRx9O/f3/mzp3Lxx9/TGhoKKdOnaJs2bK0a9eOXbt2AeDr64vJZKJdu3bJ7h08eDAmkwlvb2/u3LlDQEAA48eP58aNG/z222+EhYXRuHFjdu7caY6lPXUXQm7TatoSjl6+zhe9O3BiSgBTXmvOzPW7uXjrdor+wRFRNJv8FT8dOsGEzs04Ne1dNgzrgZ21FR3nLGPZniMZnjufnS0354+gUfniGA0G9o95m3dfSUwiWhqN3Jw/gurFC7PgrXZKbImIiJiBdm6JSJqMf9fWSoiPN3MkIiLPh61bt1KhQgV8fHwAsLOzY9q0aaxZsyZT40RFRTF//nyqVKkCQPXq1fnmm2+oXLkyAQEBHDmS8cTN0+DRfxLxCak/FMLNf2Ky1y6ODhyfHPDIMSf+vIPw+w+Y2a0lDcp5AVDOw5U5fm2o8eEnKfpPWL2dy6F3WNTTF59KJQHIa2vDwp6+1PjwE0b8sIlmlUrh4uiQ4XX1a1KL7SfPs3DrASZ3bZ7UfiDwKtfCImhTtVyGxxIREZGso+SWiKTJ8PdRRO3cEhHJGi1atGDBggX06dOHnj17UqNGDSwsLDhz5kymxnFwcEhKbD1UqVIlPDw8OHr0KNevX8c9jXuzQ9C84SnaXpm6mAJ57PnGv8tjjbntZCAAjcoXT9ZeKF8eSrgWIDA4NFn7+qOJ72nTiiWTtVtbWlC/rCcr9h9n+6nzdKlVKcMxNCznRTkPV77bd4xhbV4mv4MdAJ9s3kevhtWxstChCBEREXPQb2ARSVPSsURT6p++i4hI5nzyyScsXbqU8+fP06RJExwdHWnRogWrVq3K1DhOTk6ptru6ugIQHBz8xLE+S2Li4ol8EIONlSUONtYprhfMa5+if8T9aGysLMljm7K/S97E3VrBEVGZjqVP4xrcj4nlq52HAQgMDmP32Yt0r/dipscSERGRrKHkloikyWAwYDAYdCxRRCSLGAwGunfvzpYtW7hz5w6rV6/GZDLRoUMHZs6c+egB/hYaGooplQ8eHia1Hia5nhfWlhbksbUmOjaOqOiYFNfv3Lufor+jnQ3RsXFEPkjZP+RuYlLLNRNHEh/qVLMiLo4OfLHzMDFx8SzYsp9XX6qMk71tpscSERGRrKHkloiky2g06liiiEgWcXJy4vTp0wBYWVnh4+PD6tWrMRgMrFu3LsPjPHjwgIMHDyZr+/PPPwkKCsLb2xt3d3MeSnw6mlRIfILvtpPnk7WHRd7jr5thKfq39C4DwJbjfyVrj4mLZ9fpi9haWdKoXPEU9z2KtaUFb71cjVt3o1iwZT8/HjhO70Y1Mj2OiIiIZB0lt0QkXUYLC+K1c0tEJMv069ePY8eOER0dTXBwMFOnTsVkMtG4ceMMj5EvXz5GjBjB3r17iYqK4tChQ3Tr1g1ra2vmzJnzFKM3nxFtG+LkYMeHKzaz89QFoqJjOHv9Fv6L16R6VHGkbyNeKODEBys3s/nPv4h8EENgcBj9vlzNzYhIJnRplqli8v/01stVsbWyZNLaHbxc1gsvl/xPujwRERF5AkpuiUi6jAaDdm6JiGSRnTt3UrZsWbp27YqzszPlypVj48aNfPbZZ4wYMQIgaSfXzz//DCQ+UbFbt27JxsmTJw8ff/wxY8aMwd3dnZdffpn8+fOzbds2GjRokO3ryg6eLvlZP+RNqhRzp9dnP1F+6GwGLF1Lr4bVKefhQkxcPG7+E3n3m8QdcK6ODmx6/y3aV6/AiB82UXbITFpM+Yp7MbGsHPg63epWecSMaXPOY0+nmhUxmaBf05pZtUQRERF5THpaooiky2g0quaWiEgW8fb2ZuHChen28fX1TbWe1r89TIzlFBuG9njiMUq4OrO4b6cU7T7/eiLiQ/kd7BjXqSnjOjV94rn/rXrxIvx55Qa1S76Q5WOLiIhI5mjnloiky2hhoaclioiI/MuSXf+lX5Na5g5DREREUHJLRB5BBeVFRERg2Z4j9Fi0kqjoGJbs+i/h9x7Qtlo5c4clIiIi6FiiiDyChYWFjiWKiDwDpk+fzpAhQ5JeGwwGRo4cyfjx480YVc7n5j/xkX0Gt6qPh1NeNhw9S+lBMyntXpBFvXyxNOpzYhERkWeBklsiki7t3BIReTYMHjyYwYMHmzuM587N+SMy3PeNJyhCLyIiIk+PPm4SkXQZjUbitXNLREREREREnlFKbolIurRzS0RERERERJ5lSm6JSLqMRmOGHkkvIiLyNEVFx/DSRwvoNv8Hc4ciIiIizxglt0QkXUYLCx1LFBERszOZIMFkIiGVD1y83plGmxlLzRCViIiIPAtUUF5E0qVjiSIi8izIY2vNgbH+5g5DREREnkFKbolIuiwsLEjQzi0RERGzuXv3LmPWrMEuIgKXuXNxcXHB3d0dFxcXXFxccHV1NXeIIiIiZqXkloiky6CdWyIikkmhkfeYuX43G4+d42b4XfLa2fJSyaIMalmPikXcAGgzYykHAq8m3dOxZkXm92hLpznL2XXmYlL72Rnv8fvZy/RYtDKp7fKcodhYWTJ/y37G/LQVgAOBV3HznwiAhdFA0Lzh2bDS7JE3b166VatG099+IzQgIMV1CwsLnJycKFiwIEWKFMHDwwMXFxcKFSqEq6srLi4uVK5cmSJFipghehERkadPyS0RSZeF0aiaWyIikmE3wyNpOW0J0XFxzO7WmtqlinI1LJz3v/uVltOW8FPAG1QvXpi1g/w4cTWY1tOX4OWan+mvvwLA8v97lXYzv6Zv45r4Vi8PwCvepbk5fwRvLlzJxmNnk+byb1oL/6a18HpnGhWLurF2kF+qMXWYvYwT14JZ7t+Fal6Fn/6b8BRUKVyYXS4uNDSZCAsLIy4uLulafHw8oaGhhIaGcubMGYxGI5aWlknX4uPj2b59u5JbIiLy3FJBeRFJl56WKCIimTHh5+1cDQtnbMemNK1YAgcba8q4u7CoV3tMJhMjfvg1qW+FIq7M8WvNiavB9F+8BpMJBi9fT/2ynkmJraxgMpnAZCKn/zorZ2nJ3r17cXd3x8rKKs1+CQkJxMTEEBMTg8lkwtvbm4YNG2ZfoCIiItlMO7dEJF0qKC8iknudDgqhwfjPkrX1bFCNSa82T/OeDUfPYjQY8KlUMlm7q6MDZd1dOHr5BkF37uLhlBeAtlXLcaJFMLM37qHNjKU4Odgyu3vrLF3Hqne7Zel45lS8eHH2799Pw4YNuXDhArGxsY+8Z/jw5+eIpoiISGqU3BKRdBktLJTcEhHJpcp6uHBz/ogM94+JiyfifjQAJd+bkWa/C8FhScktgPfbNOC30xc4eP4qH7/ZBqPB8PhB5wLu7u7s2rWLxo0bc/bs2XQTXIUKFaJjx47ZGJ2IiEj2U3JLRNJlVM0tERHJIGtLC/LZ2RIVHcOluUOxNGasAsbv5y5x90E05TxcGfbtRioUdqNCkYw/AdCQC5Nhrq6u7N69Gx8fH44ePZpqgsvCwgJ3d3d2796tY4kiIvJcU80tEUmXhYUFJu3cEhGRDGr1YhniEhKSPQnxoY837eXFkfOI+8fvlcuhd3jn63V82bsjX7/dGVtrK/wWriA08l6G57SztiIm7n8fxNQZvZCvd//xZAvJAZycnNixYwd16tRJKiD/T9bW1tjY2NCoUSOqV6/Od999l6wQvYiIyPNCyS0RSZfBYNDOLRERybCR7Rri6ZKfd77+ha0nAom4H82dqPss3fUHM9bvZnSHJkk7uqKiY3hz4UrGd/ahtHtBihbIxxe9O3Az/C69Pv2J2PiMfbhSuagb54PDCLodwaHz17h06w4vlSyadL3D7GWUGTKLwxeuPZU1m5ODgwPr16+nUaNGWFhYJLVbWVkREBDAnj17OHz4MOXLl6d79+688MILjB49mjt37pgxahERkayl5JaIpMtCNbdERCQTCuZ14NehPXjFuwzDv/+V8kNnUWfMItYdOc3Sfp1oV60cAMO//5Xi707n5LVg/Bau4HRQCGGR92g/6xti4xPY+9dligyYzKwNe9hw9Cxu/hPZeOwsAC8ETMV/8ZqkOcd19qF8YVfqjllE7y9WMb6LD6UKFUy6Hp+Q8Fw8LTEt9vb2rF27llatWiUluEwmE/379wegatWqLF26lHPnzuHn58fs2bN54YUXCAgI4MqVK+YMXUREJEuo5paIpMtoNCY+Ql1ERCSDnBzsGNOxCWM6Nkmzz6RXm6f61MW0CtinV9i+pFsBfn6ve5rX07v2vLCxseHHH3/Ez8+Pb7/9lq5du1K4cOFkfTw9PZk8eTIjRozgq6++Yvr06SxYsABfX18GDx5MzZo1zRS9iIjIk9HOLRFJlwrKi4iI5AyWlpZ888039OnThyFDhqTZz9HRkYCAAAIDA/n88885deoUtWrVol69eqxdu1YfaomISI6j5JaIpMuoY4kiIjlSxIMH5g5BzMBoNLJo0SIqV678yL7W1tb4+fnx559/smvXLvLnz0+7du3w9vbm008/5YH+HxIRkRxCyS0RSZd2bomI5DxLly7Fa/x4tkZHmzsUySEe7tr6448/qF27NgMHDsTT05PRo0cTFhZm7vBERETSpeSWiKTLwmjEpJ1bIiI5wo0bN2jfvj09evSgk7c3taytzR2S5DDe3t4sWrSIixcv0q9fP+bOnUuxYsXo27cvZ8+eNXd4IiIiqVJyS0TSZdDOLRGRHGHFihVUqFCBY8eOsW3bNhZ17kweg8HcYUkOVahQIUaPHs2lS5cYP348GzdupFy5crRp04a9e/eaOzwREZFklNwSkXRZWFiQoMKyIiLPrOvXr+Pr68urr75Kp06dOHbsGA0bNjR3WGax+tBJ3Pwn4uY/kaIDp5g7nOdC3rx5CQgI4MKFC6xevZqQkBDq1KlDvXr1WLFihT4AExGRZ4KSWyKSLqOOJYqIPLNWrFhBxYoVOX78ONu3b2fRokU4ODiYO6wMeWXqYrrN/yFLx/StXp6b80dQv4xnlo4riX8faNOmDfv27UsqPv/qq69SpkwZ5syZw71798wdooiI5GJKbolIulRQXkTk2XP9+nXatm1L165d6dSpE0ePHqVBgwbmDktyiYfF58+cOUOrVq0YPnw4np6evP/++1y/ft3c4YmISC6k5JaIpMtoYUGCdm6JiDwzHtbWOnnyZI7brSXPl1KlSjFnzhwuXryIv78/n3/+OV5eXvj5+XHq1ClzhyciIrmIklsiki6jwUCCdm6JiJjdpUuXaNasGV27dqVz584cO3aMl19+2dxhieDq6sro0aO5du0an376KQcOHKBixYq0adOGLVu2mDs8ERHJBSzNHYCIPNsstHNLRMSsTCYTn332GYMHD6Zo0aLs3buXmjVrmjusZ8K5G6GMX72dPWcvEZeQQOWihRjp2zDN/rej7jNrwx42HjtL0O0I7K2tqeblQf9mtalbulim5y81aAYR96NTvWYwwH8nDMDDKW+mx82pbGxs8PPzo1u3bqxbt44pU6bg4+ND1apVCQgI4PXXX8fSUv/8EBGRrKffLiKSLoPRSHxcnLnDEBHJlS5evEjv3r3ZsWMHgwYNYsyYMdjY2Jg7rGfChZDbtJq2BHsbK77o3YHqxQtzOfQOo3/cysVbt1P0D46IotW0JdyPjWXWG614qVRRgiOimLB6Ox3nLGPG6y154//Zu++oqO7t7+PvmUFApYgVSxSxRykKFpQkFkhRB9HElqtzY9dYMP5smKhYYjAadTQW0NwkaBJbFMWoNxiNURQLURALWLFXNDZEgXn+4DKPiNIEDmW/1mLd65kz53zOMNFhs7/7tHHOcY5z88dS1szU+Od5W/cye8tf+Hq1LVGFreelDZ/XarVERESg1+vp378/fn5++Pj4MHDgQFlKK4QQIk9JcUsIkSm1Wi2dW0IIUcCe79aqWbMm+/bto3nz5krHyrVqI74iOcXw0seqfDor3Z8rWZUl2t8ny2PO2vQn/yQ8YV6fjrzTqDYAjapVRq/T0nzy4gz7fxm8i4t37hHQ3xtPh7oAWJqbsay/N80nL2bS2t9516EelaxyX3TZFHGSr3/7i16tHPF5r3Wuj1OcuLi4EBQUhJ+fH3q9nkmTJjFlyhQ++eQTxo0bR40aNZSOKIQQohiQ4pYQIlMajQaDFLeEEKLAXLhwgYEDB7J79+6879YyTe0wUhXwLMWr3/pm2PbB1z9QwaIMqz7tkatj7jxxFoB2b9qn225rbUGdyhU4e/NOuu1bI2MA8GhSN912UxMNbzW0Y92BaHadPEePlg7ZznD6m/8z/v+/L1xlZFAIbnVrMvfjD3J0LS9SJSUbv1fFhb29PXq9nsmTJ/Pdd9+xcOFCli1bRs+ePRk/fjxNmjRROqIQQogiTAbKCyEypVKrSZaB8kIIke8MBgOBgYE4ODhw48YN9u/fj7+/f94uQyxXDlQqVI+f5N0xFfA0KZmHT55iVsok3ZLANnShCgAAIABJREFUNBUty2TY/35CImalTLAwz7h/JcvUbq2b9x/lKs+V+Pvolq2juo0V3w/+kFImmlwdJ4368ROwsXmtYxRWFStWZMKECZw/f57ly5cTERGBg4MD7u7uhISEYDC8vMNPCCGEyIwUt4QQmdLIskQhhMh358+fp0OHDgwfPpzhw4dz+PBhXF1d8/5EpUphqFkTk2u38/7YBcjURIOFuSmJz5J4lPg0w+P3Hidk2N+qtBmJz5J4+CTj/rcepBa1KudiSeLDJ0/515K1PEtOYdWnPShXtnSOj/E81dNnqG/FQ/36r3Wcws7U1BSdTkd0dDShoaHY2Njg5eVF06ZNCQoK4tmzZ0pHFEIIUYRIcUsIkSm1Wk2KdG4JIUS+SOvWcnR05Pbt24SHh+d9t9YLVK1aUers5Xw7fkHp0LgOADtPnEu3Pf7hY87ciM+wf0enBgDsiD6TbvvTpGT2nLqAeSkT2jWyz/C8zCSnGBjyn42cuXGb7wd1o07l8sbHBizfwLbI2BwdD0j93qSkQBGesZYTKpUKDw8PQkJC+Pvvv3F0dGTAgAHUrFkTPz8/7t7NeHMAIYQQ4kVS3BJCZEqt0ZAiSwSEECLPnTt3jvbt26fr1nJxccn/E3fqhOnpi6gfJWS9byE2yast5cqWZvK6UHafPM+jxKfEXrvNpz9sfulSxc+921GzQjm+WB9K6LEzPHzylLM34xn6n2Bu3H/Ilz3ezfEw+SnrQ9kRfZa5/+pI6/q18uS6zCJjMDRpDG+8kSfHK0rSurZOnz7Nv//9b/R6PbVq1cLHx4eLFy8qHU8IIUQhJsUtIUSm5G6JQgiRt57v1oqPj+fAgQP4+/tjmtcDxDWa1A6gF3XtCmZmmO+PzNvzFTC7SjZsHfdvnGtVZcDyDbw5fgEjg0IY0NaVRtUq8TQpmSqfzuKzVb8BqUsOf5/Yj66ujZm09ncajpvH+7O/5/HTZ6wf9TF92jjn6PyRF6+z4s/DAPgEbaHKp7PSfW05cirH16R6koj54ZOo+vXP+GBKCqhLxkd3Ozs7/P39iYuLY8aMGWzcuJHatWuj1Wo5cOCA0vGEEEIUQnK3RCFEptQyUF4IIfLM2bNnGTBgAPv27WPMmDFMnz4974taaays4MGDjNstLODTTym7dDFP3JxIec0ZUbm1bfwnr32MOpXL88OQjzJs93zhjohpbMqWZsZHHsz4yOO1z+1U05YbSya99nGeV3bbPlSmZtCvX8YH798Ha+s8PV9hZ2VlhY+PD8OGDWPTpk3MmTOHVq1a0aZNGyZMmEDnzp1RqVRKxxRCCFEIlIxf/wghck2j0WCQzi0hhHgtKSkpBAYG4uTkxN27d/OvW+t5b7wBDx/CjRsZH/viC1RlylL2t735d36RI5pbdynz52H48suX3ynx3DmoWbPggxUCpqamdO/enYMHD7Jnzx5sbGzo0qULDRo0QK/Xk5BQtJfYCiGEeH1S3BJCZEolnVtCCPFazp49S7t27RgxYgQjRozg0KFDNG3aNP9P7OQEKhUcPJjxMUtL8J9N6T1/U+rspfzPIjKXnILVL9uhQX0YMuTl+xw6lPo9LeHc3d0JCQnh6NGjtGvXjokTJ2JnZ4efnx937txROp4QQgiFyLJEIUSmNDJzSwghciUlJYUVK1bw2WefUa9ePQ4ePIizc87mOr2WihWhWTP47TfQajM+rtPBpk2UW76R+LE6kiuWK7hshViVT2dluc/YTm8xrtNbeXZOy7W/U+riDQgLS52V9qLTpyEmBt59N8/OWdQ5OjoSEBDA9OnTWbp0KYsWLWLu3Ln861//YsyYMTRo0EDpiEIIIQqQFLeEEJmSgfJCCJFzJ06coF+/fhw5coQxY8YwY8YMSpUqVfBBevSAr76CefOgTJn0j6nVsGoVqrfcKbdsPXdHf0yKRZmXH6cEyes5WlkpExpO6bCjsGEDvKr4+f33UK0auLsXaLaioEqVKvj5+TF27Fi+++475s+fz4oVK+jYsSO+vr60bt1a6YhCCCEKgCxLFEJkSq3RSHFLCCGyKSkpidmzZ9OsWTNUKhVHjx7F399fmcIWpA4mf/oUFi16+eNly0LIFjSmpbGZuxKT67cLNl9JlmLAYv0OLIJ3pRYfu3R5+X63b8OyZanLFU3k99KvYmFhgY+PD+fOnSM4OJjbt2/Tpk0bXF1dCQoKkhELQghRzElxSwiRKencEkKI7Dl+/DitW7fGz8+PadOmERYWxptvvqlsqEqVYOJEmDkTrl59+T7Vq8PBQ2jq1Mfmm1WYRZ0u2IwlkPrhY8oF/kqZfZHwyy/g4/PqnT//HMzMYPToggtYhKnVarRaLfv372fPnj3Y29vTv39/4/D5x48fKx1RCCFEPpDilhAiU2q1mhT5bacQQrxSWreWi4sLGo2Gv//+mwkTJqB52ewkJYwdm1rkGjfu1ftUqgS7dqHq3gPrZesot2w9mpvxBZexpEhOoczOg1SYFojpnYfw527o2fPV+x8+DN99B3PmgJVVweUsJtzd3Vm7di2nTp2iU6dO+Pr6UqtWLSZOnMjVVxV7hRBCFElS3BJCZEojyxKFEOKVoqOjcXNzM3Zr7d27l0aNGikdK73SpWHxYli9GvT6V+9nZpY622nXLkxTSlFh5gqsgrZQ6vRFSDEUXN5iSH3vQWpRa+YKLEL2oBr9GcTEQsuWr37StWvQrRu0bw//+lfBhS2G6tati16v58KFCwwfPpzvvvsOe3t7dDodJ06cUDqeEEKIPCAL94UQmVKpVDKnQgghXpCUlMQ333zD1KlTadasGUeOHKFhw4ZKx3q1Dz5IHSw/ZgzUrg1eXq/et21bOBoJP/yA+aKFmM9fhaFsGZ7VtCW5vBWGMuagUhVY9KJK9fQZqoePKXXtDpqrN1Pnm/Xtm9pJZ2+f+ZMTEqBr19SbAKxZI693HqlcuTJ+fn74+vqyZs0avvrqKxwcHGjfvj2jRo1C+7K7igohhCgSpLglhMiUzNwSQoj0jh07Rr9+/Thx4gTTpk1j7NixhWcJYmbGj4eYGOjVC378Ebp3f/W+Gg0MGJD6FRuL6r//xTQyEs6fx3D7Lhjk34WsqMqUgWp14V1veOut1KKhuXnWT7x9O7WwdeYMhIeDjU2+Zy1pzMzM0Ol09OnTh99++42FCxfi5eVF06ZNGT16NB9//DEmMrxfCCGKFPlbWwiRKVmWKIQQqdK6taZMmYKrqytHjhyhQYMGSsfKmcDA1PlaPXvC8eMwdWrWXUH166d+/Y/0EOWj06ehc2d49gx274a6dZVOVKylDZ/XarVERESg1+sZMGAAU6dOZejQoQwZMoRy5copHVMIIUQ2yMwtIUSmVNK5JYQQREVF0bJlS6ZNm8b06dP566+/il5hC1I7svz9ISAAZs2CVq3g4EGlU4mEBJg9G5o1gwoVUju2GjdWOlWJ4uLiQlBQELGxsXh5eTFjxgxq1aqFj48Ply9fVjqeEEKILEhxSwiRKVmWKIQoyZ49e8bs2bNp3rw5pUuX5ujRo4XrToi5NWgQ7N8PJibQunXqn0+eVDpVyfP4cerdEBs1gi+/hClT4M8/oXJlpZOVWLVr10av13PlyhWmT5/Or7/+Sp06ddDpdBw7dkzpeEIIIV5BliUKITKl0WhIkYHyQogSKCoqik8++YSYmBimT5/OuHHjUKuL0e8FXVxg71746Sfw84MVK6BpU/D0TO0gsrUFCwulUxYvz57B3buphcR9++D33+Hp09S7IX75ZeprLgoFa2trfHx8GDZsGKtXr+brr7/G0dGRNm3aMGHCBDp37oxKBv0LIUShIcUtIUSm1CqVdG4JIUqUZ8+eMW/ePKZMmUKLFi04evQo9erVUzpW/lCpoE8f+Phj2LkTgoNh61aYPz+1EFMCPQMSgXwt61WpAq6uqUtEu3dPnYMmCiVTU1N0Oh19+/bljz/+QK/X4+XlhaOjI8OHD0en02GenRsFCCGEyFdS3BJCZEqt0ZAsnVtCiBIiMjKSfv36Fd9urVdRq8HDI/ULUruJ7t2Dhw+VzaWAdj164OrgwILJk/P+4CYmUK4cWFnl/bFFvlKpVHh4eODh4cHRo0eZN28eI0aMYOrUqQwZMgQfHx9s5M6WQgihGCluCSEypVarSTEYlI4hhBD5Kq1ba/LkybRq1YrIyEjqluQ71Zmaps59KoGzn3rodEyYMIEJs2ZRtWpVpeOIQsjZ2ZmgoCBmz55NQEAAer2eb775hv79+zNmzBhq1aqldEQhhChxSsCvIoUQr0NmbgkhirsDBw7g7OzM9OnTmTFjBn/++WfJLmyVcIMHD6Z8+fLMnz9f6SiikKtatSp+fn5cvHiRmTNnEhwcjL29PVqtlvDwcKXjCSFEiSLFLSFEplRyt0QhRDH15MkTJk6cSJs2bahRowYnT55kwoQJJWMZonglc3NzPvvsM5YsWcKtW7eUjiOKAEtLS3x8fDhz5gyrV6/m5s2buLm54e7uzrp162S8gxBCFAD59CaEyJRailtCiGIoPDycZs2asXTpUpYsWcL27dupWbOm0rFEITFs2DDKlCmDXq9XOoooQkqVKkX37t05cOAAe/bswcbGhp49e9KwYUP0ej0JCQlKRxRCiGJLiltCiExp1GpZliiEKDbSurXc3d2pWbMmx44dY/DgwahUKqWjiUKkbNmyfPbZZyxatIi7d+8qHUcUQe7u7oSEhHDq1Ck6duzIxIkTsbOzw8/Pjzt37igdTwghih0pbgkhMiWdW0KI4mL//v00bdqUZcuWsWTJErZt2ybdWuKVhg8fTqlSpZg9e7bSUUQRVr9+ffR6PRcuXGDYsGEsWrSI6tWro9PpOHXqlNLxhBCi2JDilhAiU2qNhmQpbgkhirCEhAQmTpzIW2+9hZ2dnXRriWyxsrLi888/R6/Xc/HiRaXjiCKuSpUq+Pn5ERcXx8KFCzlw4ACNGzdGq9USFhamdDwhhCjypLglhMiUWq3GIMUtIUQRtW/fvnTdWlu3buWNN95QOpYoIoYPH0716tXx8/NTOoooJiwsLBg8eDAnT54kODiYO3fu4O7ujqurK0FBQTJ8XgghckmKW0KITKnVavmgJYQoctK6td5++23s7e2Jjo6Wbi2RY6ampkyfPp0ff/yRo0ePKh1HFCNqtRqtVsu+ffvYs2cP9vb29O/f37iM8dGjR0pHFEKIIkWKW0KITKk1GgwGAwaDQekoQgiRLWFhYTg7OxMQEGDs1qpRo4bSsUQR1bt3b5o2bcrnn3+udBRRTLm7u7N27VpiYmLo3LkzkyZNonr16vj4+HDlyhWl4wkhRJEgxS0hRKbU6tS/JmSovBCisHu+W6tu3brG2VpCvA6VSsXs2bPZunUru3btUjqOKMbq1KljHD7v6+vLunXrsLe3R6fTcfz4caXjCSFEoSbFLSFEpjT/K27J3C0hRGG2d+9enJycCAgIYOnSpfz222/SrSXyTIcOHfjggw8YPXo0SUlJSscRxVylSpWYMGEC58+fZ/ny5Rw+fBgHBwc8PT0JCQlROp4QQhRKUtwSQmRK9b/iltwxUQhRGD1+/JiJEyfyzjvvUL9+feNsLSHy2sKFC4mNjWXRokVKRxElhJmZGTqdjujoaDZt2gSAl5cXTZs2JSgoSAqtQgjxHCluCSEypdFoAFmWKIQofPbs2YOTkxOBgYEsXbqULVu2UL16daVjiWKqbt26jBs3jqlTp8ocJFGg0obPh4aGEhERgYODAwMGDKBmzZr4+flx7949pSMKIYTipLglhMiUceaW3DFRCFFIpHVrtW3bloYNG0q3ligwvr6+VKpUif/7v/9TOooooZo1a0ZQUBCxsbHodDoWLFhAzZo18fHx4dKlS0rHE0IIxUhxSwiRKRkoL4QoTEJDQ2nUqJGxWyskJIRq1aopHUuUEKVLl2bJkiWsWbOGbdu2KR1HlGC1a9fG39+fixcvMmPGDDZs2ECdOnXo0aMHhw4dUjqeEEIUOCluCSEypZZliUKIQuD+/fsMGTKE9957j5YtWxITEyPdWkIR7733Hl27duWzzz4jMTFR6TiihLOyssLHx4ezZ8+yYsUKTp48SYsWLXB3dyckJASDwaB0RCGEKBBS3BJCZEqtUgGQLMsShRAK+e9//4uDgwPBwcGsXbuWtWvXUqlSJaVjiRJswYIFXL16lcmTJysdRQgATE1N0el0HDt2jD179mBjY0OXLl1wdnYmMDCQJ0+eKB1RCCHylRS3hBCZShsob5DOLSFEAfvnn38YMmQIH3zwAS1btiQ6OpqPPvpI6VhCULNmTebNm8c333zD7t27lY4jRDppXVtHjhzBycmJESNGYGdnh5+fH/Hx8UrHE0KIfCHFLSFEplT/m7mVLMUtIUQB2r59Ow4ODmzatIl169ZJt5YodAYOHEiXLl3o168fDx48UDqOEBk4OTkRFBTExYsXGTp0KAsXLqRWrVoMGTKE2NhYpeMJIUSekuKWECJTGpm5JYQoQGndWh07dqRVq1ZER0fz4YcfKh1LiJdatmwZjx49Yty4cUpHEeKVbG1t8fPzIy4ujpkzZ7J9+3YaNWqEVqtl//79SscTQog8IcUtIUSmjHdLlJlbQoh8tm3bNpo0acKmTZtYv349a9eupWLFikrHEuKVKleuTEBAAIGBgWzdulXpOEJkytLSEh8fH86fP09wcDC3bt2idevWuLu7s27dOpmvKoQo0qS4JYTIlLG4JZ1bQoh8cu/ePWO3lpubG8ePH6dbt25KxxIiW7y9venduzeDBg3i1q1bSscptMaOHYuFhYXSMQSpn+20Wi3h4eHG4fM9e/akYcOG6PV6Hj9+rHREIYTIMSluCSEyJcUtIUR+2rp1Kw4ODmzevJkNGzawdu1aKlSooHQsIXLk22+/xczMjN69exe57pe5c+eiUqlQqVTUqFEjy+2ieEkbPh8TE0PHjh3x9fU1Dp+/ffu20vGEECLbpLglhMhUWnGrqH1YF0IUbmndWp06dcLNzY3o6Gi6du2qdCwhcsXGxoaNGzeyf/9+Jk+erHScHBk7diwGgwEnJ6dsbRfFU7169dDr9Vy4cIFPP/2Ub7/9lho1aqDT6Th58qTS8YQQIktS3BJCZCptoLzBYFA4iRCiuPjtt99o0qQJmzdvJjg4WLq1RLHg5OREQEAA/v7+bNiwQek4QuRK5cqV8fPz4/LlywQGBnLw4EGaNGmCVqtlx44dSsfLlIWFBe7u7krHEEIoRIpbQohMqaRzSwiRR9K6tTp37kzr1q05fvw4Xbp0UTqWEHmmT58+9O/fn08++YRTp04pHUeIXDM3N0en03HixAmCg4OJj4/H09MTV1dXgoKCSEpKUjqiEEKkI8UtIUSm0jq3ZOaWEOJ1bNmyhcaNGxMSEsKmTZtYu3Yt5cuXVzqWEHnu22+/pV69evTq1UsGc4siL234fFhYGIcPH+bNN9+kf//+1K9fH71ez6NHj5SOKIQQgBS3hBBZMA6Ul84tIUQu3L17lyFDhqDVamnTpg3R0dF4eXkpHUuIfGNubs769eu5fPlyrgfMe3t7G4e5q1SqdEut/vjjD1QqFSEhIcZto0ePTrd/UlISSUlJrFmzBk9PT2xtbSldujQODg7o9frX+oXVqlWr0p1LpVJx/fr1XB/vVU6dOoW3tzfW1taUKVOGFi1asGXLFjw8PIznHThwoHH/O3fuMGbMGOrUqYOpqSk2NjZ88MEH7Nq1K8+zlVQuLi4EBQURGxuLVqtl0qRJVKtWDR8fH65cuZIv50xMTGTKlCk0bNiQMmXKUL58ebRaLZs3bzb+t5V284NHjx4RFhZmfH+YmJikO1Z23iMv3kjh0KFDdOjQAUtLS8qUKUO7du0ICwvLl2sVQrweKW4JITKlUqkA6dwSQuTcunXraNCgAVu2bGHz5s3SrSVKjNq1a7N161b++OMPhg0bluPnBwcHs3jxYgB++ukn9u7da3xs1apVxu1pFixYwMaNG+nQoQMGgwETExO2b99Or169aN++PSdPnuTSpUsMHjyYMWPGMGHChFxfW+/evRkzZgyenp7Ex8djMBiwtbXN9fFe5syZM7i5uXH48GHWr1/PzZs3+f7779Hr9URFRWFmZobBYGDFihUAXL9+nebNm/Pzzz+j1+u5ffs2Bw4coEyZMnTo0MG4n8gb9vb26PV64uLimDRpEuvXr8fe3h6dTkd0dHSenmvEiBEsXLiQRYsWcefOHU6ePEnDhg3p0qULe/bsAf7/zQ/Kli1LmzZtMBgMGAyGdEsns/seef5GCvfu3cPHx4eZM2dy/fp1/vrrL+Lj42nfvj27d+/O0+sUQrw+KW4JITIlyxKFEDl18+ZNunfvTs+ePenatSsnT55Eq9UqHUuIAtWiRQt++eUX/vOf/zBr1qwcP79Xr16YmpqycuVK47aEhAQ2bdpE3bp12bx5Mw8ePDA+FhQUhE6nS3eMtm3b4uvri42NDRUrVmTkyJF8/PHH6PV67t+/n+NM9+7do1OnTiQnJ7Nt2zZsbGxyfIzsmDRpEvfu3UOv1+Pp6YmFhQWNGzfm559/fukyOF9fX86fP8+CBQvo3LkzVlZW1K9fn59//pmqVasyatQobty4kS9ZS7KKFSsyYcIEzp07x/Lly4mIiMDBwQF3d3dCQkLy5GZEf/zxB40bN8bT05PSpUtTpUoV5syZQ/369XN0nNy8Rx49esSSJUtwc3OjbNmyuLq6smrVKp4+fYqPj89rX5sQIm9JcUsIkSnjskQpbgkhsmHdunU0adKEQ4cO8fvvvxMQEICVlZXSsYRQhFarZfHixXzxxRf88MMPOXpu+fLl6dixI6GhocZlf5s2baJly5YMHz6chIQE410Z4+Pj+fPPP+nWrZvx+Z07d37pkjwnJyeePXvG8ePHc5QnJiaGli1bolarWbBggfGXX/lh+/btALz33nvptleqVImGDRtm2H/jxo0AdOrUKd12MzMzOnToQEJCAv/973/zKa0wMzMzdm2FhoZiY2ODl5cXzZo1IygoiGfPnuX62O+//z779u1j8ODBhIeHG5cixsTE0LZt22wfJzfvkbJly+Ls7Jxum4ODA9WqVSMyMpJr167l4oqEEPlFiltCiExJ55YQIjtu3rzJRx99ZOzWOnbsGB4eHkrHEkJxQ4YMYfz48QwePJjff/89R8/V6XQkJyfz888/A7By5Up0Oh29e/dGo9EYlyb+8ssvdO7cGQsLC+Nz//nnH6ZMmYKDgwM2NjbGOULjxo0DyNGw+7t37+Lt7U2NGjXYtm2bcWlkfkhMTOTBgweYm5unu540L3aLJSYm8s8//2Bubo6lpWWG/atUqQKQL3PBRHoqlQoPDw9CQkL4+++/cXBwYMCAAdSqVQs/Pz/u3r2b42MuXryYoKAgzp07R4cOHbCysuL99983FquyI7fvkXLlyr30eJUrVwZS/90TQhQeUtwSQmRK9b/OrdwMxBVClAzr1q2jcePGREREEBoaSkBAwEt/gBCipPrqq6+Mhd8//vgj28/r1KkT5cuXZ+XKldy6dYvw8HC8vb2pUqUK7777Ljt37uTatWv8+OOPGZYkarVaZsyYwaBBg4iNjSUlJQWDwcD8+fMBcrRkzMTEhB07drBp0yYcHBwYNGgQhw4dyvbzc8LMzAxLS0uePHnCw4cPMzz+YkHBzMwMa2trnjx5km6ZZpq0pWZ5PRdMZK5p06YEBQVx+vRpdDoder2eWrVq4ePjw8WLF7N9HJVKRd++fdmxYwf37t0jODgYg8FAt27dmDdvXoZ9Xya375E7d+689L+TtPdgWpFLCFE4SHFLCJEp6dwSQrzKjRs3+PDDD+nZsyfdunUjKiqKDh06KB1LiEJHpVLxww8/8OGHH9KpU6d0dzrMjKmpKT179uTo0aN8/vnndOnShdKlSwPQt29fkpOTmTp1KteuXaN9+/bG5yUnJxMWFoatrS2jRo2iUqVKxh/8ExIScpzf0tKS6tWrY2FhwebNm7GwsMDb2zvflmV98MEHwP9fnpjm+vXrxMbGZti/a9euAPz222/pticmJvLHH39QunTpDEscRcGws7PD39+fuLg4ZsyYwcaNG6lbty49evTg4MGDWT6/XLlynDp1CoBSpUrh6elJcHAwKpUqw/e7TJkyPH361PjnBg0aEBgYCOTuPfLkyZMMRdxjx45x9epVnJycqFq1ajZfBSFEQZDilhAiU+q0uyVK55YQ4jlp3VpHjhxhx44d0q0lRBY0Gg3ff/89vXv35qOPPiI4ODhbz+vbty8Ay5cvT9ed5e3tjaWlJcuXL+df//qXcUZm2rnatm3L9evXmTNnDrdv3yYhIYFdu3axbNmy17oOOzs71q9fz61bt+jWrRuJiYmvdbyXmTVrFuXLl2f06NGEhoby8OFDoqOj6dev30s7sL766itq167N6NGj2bJlCw8ePCA2NpaPP/6Ya9euodfrjUvPhDKsrKzw8fHhzJkzrFixglOnTtGyZctsDZ8fOnQoUVFRJCYmcvPmTb7++msMBkO6gi5As2bNiI2N5dKlS+zfv59z587x1ltvAbl7j1hbWzNp0iT279/Po0ePOHz4MH369MHU1BS9Xp/3L5IQ4rVIcUsIkSmVDJQXQjzn+vXrdOvWjZ49e/Lhhx8SFRWV4QcMIcTLaTQa/vOf/zBw4EB69OhhHAifGTc3N+rVq0fNmjV55513jNtLly7Nhx9+CJBhSSLAmjVrGDJkCIsWLaJatWrUrl2boKAgPv74YwA8PT1xdXVl7ty5qFQqIiMjuXLlCiqVii+++ILVq1dn2L5gwQLCw8Np27Ytz549Izw8HHNzc/r06ZNHr1CqOnXqsH//fpo3b85HH31ElSpVGDJkCL6+vtSuXTvDMHtbW1sOHTpE7969GTVqFBUqVKBFixY8evSIHTt2MGjQoDzNJ3LP1NQEPaumAAAgAElEQVQUnU5HVFQUe/bswcbGhi5dutCgQQP0en2GzsLdu3fTsGFDevXqRfny5WnUqBHbt29n+fLlTJo0Kd2+CxYswNHRkUaNGtGzZ0/0ej2NGjUCcvcesbCwYNGiRUybNo2qVavy9ttvY2Njw86dO9P9tyiEKBxUhry4R6sQxdD8+fD1HAPhx+8pHUVR/9y7h5O9Pas2bsRd/iEXufDh+1a4u2lYsEDpJOJ1rVu3jmHDhmFlZcV3331Hu3btlI4kRJFkMBgYPnw4K1as4IcffjAWnIqzsWPHsmzZspfO0cqJhg0bkpCQQFxcXB4lE0qLiooyDo63trZm6NChjBw5kgoVKiiWydnZmdu3b3P58mXFMgghcuSKdG4JITKVtsxBliUKUXJdv36drl27puvWksKWELmnUqlYvHgxI0eOpE+fPvj5+eVowHtxd/36dcqXL8+zZ8/Sbb9w4QJnz56VbtFixtHRkYCAAM6fP8/QoUNZtGgRdnZ2DBkyhJiYGKXjCSGKCCluCSEypZaB8kKUaGmztaKioti5cycBAQFYWFgoHUuIIk+lUvHNN98QEBDArFmz6NGjB48fP1Y6VqFx9+5dhgwZwqVLl3j8+DEHDx6kZ8+eWFlZMXnyZKXjiXxga2uLn58fcXFxzJw5k//+97+8+eabaLVa9u3bp3Q8IUQhJ8UtIUSm0jq3kqVzS4gS5dq1a3Tp0oVevXrx0UcfERUVRdu2bZWOJUSxM2jQIHbu3Mnu3btp3bo1Fy9eVDqS4mxtbdmxYwf37t0zzjny8vKiXr16HDx4EHt7e6UjinxkYWGBj48P586dIzg4mNu3b9OmTRtcXV0JCgrK18+kr5pBJ4Qo/GTmlhCvIDO3UiUmJtKgalWW//QTnv+7NbcQOSEzt4qedevWMXToUGxsbPjuu+9kcK4QBeDs2bNotVr++ecfgoODad68udKRhCg09u7dy8KFC9mwYQN2dnaMHDmSQYMGUaZMGaWjCSEKB5m5JYTInEZmbglRYly7dg0vLy9jt1ZkZKQUtoQoIGl3CHRycuKtt95i/vz5ModLiP9xd3dn7dq1nDp1ik6dOuHr64udnR0TJ07k6tWrSscTQhQCUtwSQmRKlVbckg/YQhRbBoOBoKAgGjduzMmTJ9m1axcBAQGULVtW6WhClCjW1taEhIQwefJkxo8fT8eOHeUHdyGeU7duXfR6PRcuXODTTz/lu+++w97eHp1Ox4kTJ5SOJ4RQkBS3hBCZ0shAeSGKtbi4ON59910GDBhA3759iYyM5O2331Y6lhAllkaj4fPPP2fv3r2cOXOGN998k8DAQOniEuI5lStXxs/Pj8uXLxMYGMihQ4dwcHBAq9WyY8cOpeMJIRQgxS0hRJbUarUsSxSimDEYDAQGBuLg4MC1a9cICwtDr9fL/BIhComWLVsSFRXF4MGDGT58OO+88w4RERFKxxKiUDEzM0On03H8+HGCg4O5e/cunp6euLi4EBQURFJSktIRhRAFRIpbQogsqdVq6dwSohi5cOECnp6eDB8+nE8//ZSIiAhatGihdCwhxAtKly7N119/TXh4OElJSbRo0YK+ffvKHRWFeIFarUar1bJ3714OHz5M48aNGTBgAPXq1WP27Nn8888/SkcUQuQzKW4JIbKk1mjy9bbLQoiCkdat5ejoyPXr19m3bx/+/v6YmZkpHU0IkQkXFxf27dtHcHAw4eHh1KtXDx8fH/mBXYiXSOvaiomJwcvLixkzZlCzZk18fHy4fPmy0vGEEPlEiltCiCypVSoM0rklRJF2/vx5PDw80nVrNW/eXOlYQogc0Gq1HD9+nNmzZ/PTTz9Rr1499Ho9jx8/VjqaEIWOvb09er2eK1euMH36dH799Vfq1KmDTqcjOjpa6XhCiDwmxS0hRJZkWaIQRdfz3Vo3b95k//790q0lRBFmamrK6NGjOX36NP/+97+ZNGkStWrVYtq0ady5c0fpeEIUOtbW1vj4+HDu3DmWL1/O33//jYODA+7u7oSEhMjNGoQoJqS4JYTIklqjIVmKW0IUOefPn6dDhw4MHz6c4cOHc/jwYVxdXZWOJYTIAzY2NsyZM4e4uDiGDx/OokWLqFWrFj4+PjKTS4iXMDU1RafTcezYMUJDQ7GxscHLy4umTZsSGBjIkydPlI4ohHgNUtwSQmRJOreEKFqe79a6ffs24eHh0q0lRDFVsWJF/Pz8iIuLY+bMmQQHB1O3bl10Op3cXVGIl1CpVHh4eBASEsKRI0dwdHRkxIgR1K5dGz8/P+7evat0RCFELkhxSwiRJY1GQ4oMlBeiSDh37hzt27dnxIgRxm4tFxcXpWMJIfJZ2bJlGT16NGfOnGHFihUcOXIEV1dXXF1dCQwM5MGDB0pHFKLQcXZ2JigoiLi4OIYMGYJerzd2QMbFxSkdTwiRA1LcEkJkSSWdW0IUes93a8XHxxu7tUxNTZWOJoQoQKVKlTIuvUorbn/22WdUrlyZHj16sGPHDqUjClHoVK1aFT8/Py5evMiMGTPYuHEj9vb2aLVaDhw4oHQ8IUQ2SHFLCJEljVpNsnRuCVFonT17lnbt2jFixAhGjBjBoUOHaNasmdKxhBAKc3FxISAggMuXL+Pv78+JEyfw9PTExcWFJUuWcPv2baUjClGoWFpa4uPjw9mzZ1m9ejU3btygVatWMnxeiCJAiltCiCyp1WoM0rklRKGTkpJCYGAgTk5O3Lt3jwMHDki3lhAiAxsbG3x8fIiOjmbv3r00adKE8ePHU7VqVTp27EhQUBD3799XOqYQhUapUqXo3r07Bw8eZM+ePdjY2NClSxcaNGiAXq8nISFB6YhCiBdIcUsIkSW1Wk2K/KZKiELlzJkzGbq1mjZtqnQsIUQh16ZNG3788Udu3brFhg0bsLCwYNCgQVSpUgWtVktQUBCPHj1SOqYQhUZa11ZkZCTt2rVj4sSJ2NnZ4efnx507d5SOJ4T4HyluCSGypNZoZFmiEIVEUlISer0eJycn7t+/z8GDB/H396dUqVJKRxNCFCGlS5dGq9Wydu1arl+/zrfffktCQgL9+/enWrVq6HQ6fv31Vx4+fKh0VCEKBQcHBwICArhw4QLDhg1j0aJFVK9eHZ1OR0xMjNLxhCjxpLglhMiSWgbKC1EoHD9+nDZt2jBx4kTGjRvHwYMHcXZ2VjqWEKKIs7GxYcCAAezYsYPLly8zY8YMLly4QM+ePalYsSIdO3YkICCAq1evKh1VCMVVqVIFPz8/4uLiWLhwIQcOHODNN99Eq9USFhamdDwhSiwpbgkhsqTRaEiRzi0hFJOUlMTs2bNxcXFBpVLx999/4+fnJ91aQog8Z2try6hRo/jrr7+4efMmK1eupGLFiowfP57q1avTuHFj/Pz8iIiIkOHaokSzsLBg8ODBnDx5kuDgYO7cuYO7uzuurq4EBQXJqgchCpgUt4QQWVKpVNK5JYRCjh8/TuvWrfHz82PatGmEhYXRqFEjpWMJIUqA8uXL0717d4KCgrhx4wahoaF4eHiwYsUKXF1dqVatGj169CAwMJBr164pHVcIRajVarRaLfv27WPPnj3Y29vTv39/6tevj16v5/Hjx0pHFKJEkOKWECJLGpm5JUSBe75bS6PRcOTIESZMmIBGo1E6mhCiBDI3N8fDwwO9Xs/Fixc5cOAAQ4cO5erVqwwfPpwaNWrQokULPv/8c3bv3s3Tp0+VjixEgXN3d2ft2rXExMTQuXNnJk2aRLVq1fDx8ZFlvULkMyluCSGypFbLXxVCFKTo6Gjc3NyYNm0a06ZNY+/evTRs2FDpWEIIAaR+LmjRogVTp05l79693L59m19//RVXV1fWrFlD27ZtqVChAlqtFr1ez9GjR6UDXJQoderUQa/Xc+HCBXx9fVm3bh21a9dGp9Nx4sQJpeMJUSzJT6xCiCyp1Wrp3BKiAKR1a7m6ulKqVCn+/vtv6dYSQhR61tbWeHt7s2TJEs6cOcPZs2eZM2cOpqamTJ8+naZNm1KxYkW8vLz45ptvOHToEElJSUrHFiLfVapUiQkTJnD+/HmWL1/O4cOHadKkCZ6enoSEhCgdT4hiRYpbQogsqTUa+Y2rEPns2LFjtGrVytittWfPHunWEkIUSfb29gwdOpRff/2VW7duERkZiZ+fH6ampnz99de0aNGC8uXL07FjR/z9/dm3b58sYxTFmpmZGTqdjujoaDZt2gSAl5cXzZo1IygoSIq9QuQBE6UDCCEKP7VaLXdLFCKfJCUl8c033zBlyhRcXV05cuQIDRo0UDqWEELkCbVajaOjI46OjowaNQqAc+fOsXfvXsLCwli2bBm+vr6UKlUKR0dH2rRpg4uLC+7u7tjb2yucXryOO3fucOvWLR49eqR0lEKlWrVq+Pv7c+zYMVatWkW/fv3w9fVl4MCBeHl5KR1PiAJhZWVF1apVsbCwyLNjSnFLCJEljVotnVtC5IOoqCj69evHyZMnmT59OuPGjZMZd0KIYs/e3h57e3t0Oh0Ap0+fZt++fYSHh7N7924WL15McnIyNWrUwM3NDTc3N1q2bImLiwtmZmYKpxevkpiYSHBwMMHBwfz1118yQD0Hrl69yvTp05k+fbrSUYQoMGq1mjp16tChQwe6d+9Ou3btUKlUuT6eFLeEEFlSycwtIfLUs2fPmDdvHlOmTKF58+YcPXqU+vXrKx1LCCEUUa9ePerVq8e///1vAB4+fMihQ4fYv38/4eHhfPXVV9y6dQtTU1OcnZ1xcXHBxcUFV1dXGjdujImJ/EijpKSkJJYsWcKXX35JfHw877zzDqNGjaJZs2bY2tpStmxZpSMKIQqZ+/fvExcXx+HDh9m2bRvLli2jYcOG+Pv706VLl1wdU/4lEEJkSaPRkGIwKB1DiGIhMjKSfv36ERMTI91aQgjxEhYWFrRr14527doZt505c4bw8HAOHjxIREQEP/74I48fP8bc3BwnJydjwcvFxUUKXgVo586djBo1ijNnzjB69GhGjhxJ9erVlY4lhCgCnJ2d6dKlCzNmzODYsWP4+/vTtWtXPD090ev1OZ49K3/rCyGypFarMciyRCFeS1q31uTJk2nZsiVHjx6lXr16SscSQogioW7dutStW5c+ffoAkJyczMmTJzl8+DARERFERETw/fffk5CQQOnSpXF0dMTZ2RlnZ2ccHR1xcHDA0tJS4asoPgwGA7NmzWLy5Ml4eXmxadMm6tSpo3QsIUQR5eDgwE8//cSnn37KqFGjcHV1ZdWqVXh7e2f7GFLcEkJkSZYlCvF6IiMj+eSTT4iNjWXGjBnSrSWEEK9Jo9HQpEkTmjRpwieffAKkLo97vuAVGRnJL7/8wv3791GpVNjb2xuLXY6Ojjg5OVG7dm1lL6QISkxMZPDgwfz000/o9XpGjhypdCQhRDHRpk0bDh48yOjRo+nWrRtTpkzBz88vW8+V4pYQIksajUYGyguRC0+ePMHf359Zs2bRqlUrIiMjqVu3rtKxhBCiWDIxMcHBwQEHBwf69esHpHYYXbhwgcjISKKiooiKiiIoKIhz585hMBiwtrbGwcHBWChr1KgRTZo0oXLlygpfTeFkMBjo06cPoaGhbN26lXfffVfpSEKIYkaj0bBo0SLq1KnD2LFjKVOmDOPHj8/yeVLcEkJkSa1WkyKdW0LkyIEDB+jXrx9Xrlxhzpw5jBw5Urq1hBCigKlUKmrXrk3t2rXTLW958OAB0dHRREZGEhkZyfHjx1m7di3x8fEAVKxY0VjscnBwMBa9KlasqNSlFAqTJ09m06ZNbN++nfbt2ysdRwhRjI0ePRqVSsWYMWOoX79+lksU5VO2ECJLarVaOreEyKYnT54wceJE2rRpwxtvvMGxY8fw8fGRwpYQQhQilpaWuLm5MXToUJYuXcpff/3FnTt3uHr1KqGhoXzxxRfUr1+fqKgoJk2aRLt27ahUqRJVqlShbdu2DB48mDlz5hAcHMzJkyd5+vSp0peU79atW8esWbMIDAwsFIWtuXPnolKpUKlU1KhRI8vtRcmqVauM16BSqbCwsFA6UrGxevVq4+tqbm6udJx8VRivdeLEiene261atcp0fx8fH4YMGUKfPn04ceJEpvuqDAa5BZoQLzN/Pnw9x0D48XtKR1Hcv7t3p7KtLXMWLVI6iiiCPnzfCnc3DQsWKJ0k/4WHh9OvXz+uXr3KnDlzGDRoECqVSulYQgghXtOVK1c4fvw4x48fJyYmhtjYWE6fPs3ly5eB1GU0tWrVon79+savevXqUb9+fWrWrFkofsFx4cIFKlSokKvB+g8fPqRBgwZ07tyZgICAfEiXe87Ozty+fdv4vchq+8s8fPiQpk2b0qBBA7Zs2ZJfUbNt1apV9O3bl6VLlzJ06FCl4xRLHh4e7N27lydPnigdJd+97FoLw3vexMQEV1dXwsPDM90vKSkJNzc3rK2t2bFjx6t2uyLLEoUQWZLOLSEy9+TJE/z8/Jg7dy4eHh78/vvvvPHGG0rHEkIIkUeqV69O9erVM8yYSkxMNBa+Tpw4wblz5zhx4gTr1q3j2rVrAJiamlKjRg3s7e158803ady4Mfb29tjb21O7du0C+yXI6tWr8ff357PPPmPkyJGUL18+28+dOXMmCQkJfPnll/mYUDkGg4GUlBT5vFtIWFhY4OzszN69e5WOUmwVpfe8iYkJixYtonXr1mzYsIFu3bq9fL8CziWEKII0Gg2GIvAXnxBK2L9/P/379+fatWssWbJEurWEEKIEMTMzMxaqtFptusfu3LlDbGys8ev06dPs3r2bFStW8PjxYwCsra2NXV4NGjSgTp062NnZUbt2bapWrZqn/55cunSJBw8eMHPmTGbPns3IkSMZM2YMVapUyfR5V69eZcGCBcydO7fYzhyztLTk7NmzSscQosAUtfd8q1at6NOnDxMnTsTb2/ul3bBS3BJCZEmlVpMsA+WFSCchIYFp06Yxd+5cPD09pVtLCCFEOhUqVMDNzQ03N7cMj126dInTp08bi16xsbH89NNPXLhwwTi/y8zMjFq1amFnZ2f8ql27tvH/29ra5ijPhQsXjJ0aSUlJzJ8/n3nz5tGrVy+mTp36yrv5fvfdd1hZWTFo0KCcvwhCCJFHfH19ady4MTt27HjpnVqVX/wthCj0NBpNkWhZFaKg7Nu3j6ZNm7Js2TKWLFnCtm3bpLAlhBAi29544w3at2/P0KFD+eabbwgJCSEmJobExETi4+M5fPgwK1eupH///tjZ2XHu3DlWrFhB3759cXNzo2rVqpibm1OnTh08PT0ZMmQIs2fPJigoiB07dnDu3DleHK18/vz5dH9+9uwZSUlJrF27loYNG9K3b19OnTqVIev69evp3bs3ZmZmWV6Xt7d3umHR7u7uxsf++OMPVCoVISEhxm1pd0NL+0pKSiIpKYk1a9bg6emJra0tpUuXxsHBAb1e/1qfR18c0q5Sqbh+/TrBwcHptqXNJXpx+4ULF+jZsyflypWjQoUKdO7c+aWdL6dOncLb2xtra2vKlClDixYt2LJlCx4eHsZjDRw4MNfXkdPX586dO4wZM4Y6depgZmZGjRo18PDw4IcffiAhISHX+966dYtRo0ZhZ2eHqakplSpVolu3bhw9etS4z4vD/Q8dOkSHDh2wtLSkTJkytGvXjrCwsAz7P3r0iLCwMONzTUxMcnzuNM9/P8qWLctbb72VJ8sdc3ptOcmeF++9zK61qL3n0zRq1IgWLVqwbt26lz4uxS0hRJbUKhUp0rklBAkJCUycOJG33noLe3t7oqOjGTx4sNKxhBBCFCM2Nja4uLjQvXt3JkyYQEBAAKGhoZw9e5aEhATOnz/Prl27WLZsGX369KFatWqcPHmSxYsX069fPzw9PalTpw6WlpY0adIErVbLqFGjiIuLe+n5nj59SnJyMmvWrOHNN9+kU6dOREREAHDjxg2ioqL44IMPspU9ODiYxYsXA/DTTz+l+8F61apVxu1pFixYwMaNG+nQoQMGgwETExO2b99Or169aN++PSdPnuTSpUsMHjyYMWPGMGHChFy9pgC9e/dmzJgxeHp6Eh8fj8FgwNbWFm9vbwwGA126dEm3/4vbR48ezejRo7ly5Qpr1qxh586d9O7dO91zzpw5g5ubG4cPH2b9+vXcvHmT77//Hr1eT1RUFGZmZhgMBlasWJHr68jJ63P9+nWaN2/OL7/8gl6v5/bt20RERNC2bVv69euX7uYAOdn32rVrNG/enLVr17JkyRLi4+P5888/iY+Px83Njf379wMwduxYDAYDTk5O3Lt3Dx8fH2bOnMn169f566+/iI+Pp3379uzevTvd/mXLlqVNmzYYDAYMBgNJSUk5PvfLvh83btxgyZIlzJgx47WX5OX02nKSPS/ee5lda1F7zz+vY8eOrxwqL8UtIUSW1NK5JQRhYWE4OzsTEBDA0qVL2bp1a5G9xbgQQoiiycTEBDs7O9q2bcsnn3zCtGnT+PHHH/nrr7+4ePEiCQkJnD59mtDQUBYsWGDspjh06JBxzterPHv2DIPBQGhoKM2bN6djx46sXr0aAFdX12xn7NWrF6ampqxcudK4LSEhgU2bNlG3bl02b97MgwcPjI8FBQWh0+nSHaNt27b4+vpiY2NDxYoVGTlyJB9//DF6vZ779+9nO0uae/fu0alTJ5KTk9m2bRs2NjY5PsbAgQNxc3OjbNmyeHh40KlTJw4dOsTt27eN+0yaNIl79+6h1+vx9PTEwsKCxo0b8/PPP/Po0aMcn/NVsvv6+Pr6cv78efR6PZ07d8bS0pIqVarwxRdf8P7776c7Zk73jYuLY968eXTs2NF4natXr8ZgMDBy5MgMmR89esSSJUuMr6GrqyurVq3i6dOn+Pj4ZPvac3Lul30/HBwc+P777403fMgL2b223LxukPv33utea2F6z6dxdXUlLi6Oe/fuZXhMiltCiCyp1WpSXmhtF6KkePz4MRMnTuTtt9+mbt260q0lhBCi0DI1NaVu3bp4eHgwcOBAZs6cyapVqwgKCsr2MdKKXNu2bWP06NFoNBpOnDiR7eeXL1+ejh07EhoayvXr1wHYtGkTLVu2ZPjw4SQkJLBhwwYAY+fK83c/69y5M7t27cpwXCcnJ549e8bx48eznQUgJiaGli1bolarWbBgARqNJkfPT9O8efN0f04bR3D16lXjtu3btwPw3nvvpdu3UqVKNGzYMFfnfVFOXp+NGzcCvLTzLu37m5t9g4ODUavVdO7cOd1+tra2NG7cmIiICC5fvpzusbJly+Ls7Jxum4ODA9WqVSMyMjLbBZicnPtV349q1apRv379bJ0vO7J7bbl53eD13nuvc62F5T3/PDs7OwwGA1euXMnwmBS3hBBZUqvVsixRlEh79+5N163122+/Ub16daVjCSGEEDly6dKlLPfRaDTG2Ubm5ua8/fbbvPfee1hbW2f4wT0rOp2O5ORkfv75ZwBWrlyJTqejd+/eaDQa49LEX375hc6dO2NhYWF87j///MOUKVNwcHDAxsbGOLNn3LhxAFl2oD3v7t27eHt7U6NGDbZt22ZcGpkb1tbW6f5samoKYFzdkJiYyIMHDzA3N093PWly0y32Mtl9fRITE/nnn38wNzfH0tIy02PmZt+UlBSsra0zzDH7+++/ATh9+nS655UrV+6lx6tcuTIAN2/ezPLac3LurL4faefNC9m5tty+bvD6773cXmthec8/L+39+bIOTiluCSGyJAPlRUmT1q31zjvvUL9+/QLt1lq9erXxg465uXmBnPNFLw5JfR0vDvB92Yef/PSqoamFyYEDB9BqtVSrVg0rKytat26NXq8nPj4+18dcu3YtKpUqWwOgSyKl3xcTJ05Md/5WrVoV6PlFyXP58mXU6vQ/+pUqVQqVSgWk/vD70UcfMX/+fCIiInjw4AG7d+/mvffeo3Tp0lhZWeXofJ06daJ8+fKsXLmSW7duER4ejre3N1WqVOHdd99l586dXLt2jR9//DHDkkStVsuMGTMYNGgQsbGxpKSkYDAYmD9/PkCGQfmZMTExYceOHWzatAkHBwcGDRrEoUOHcnQt2WVmZoalpSVPnjzh4cOHGR7PTvEmO7L7+piZmWFtbc2TJ0/SLQN9Vfac7FuuXDlMTEyMXX4v+2rXrl265925c+el37u01+X5Akza+/J1zp3V9+N1/o19UXauLbevW3YU5LXm5Lx59Z5/XtrfYy/72VSKW0KILKnUapKlc0uUEHv27MHJyYnAwECWLl3Kli1bCrRbq1evXhgMBjp06JCr5z98+JB69eplaHnPieeHpOaVpUuXYjAY0n34yYusWXnV0NTCIiwsDHd3d1JSUggLC+PatWv4+PgwYcIExo8fn+vjVqpUKd3/Pq8gXvfCTun3hb+/v/EHmdwukRIiJy5dumT8YVCj0eDo6MiwYcP45ZdfuHTpEjdu3GD16tWMGDGCZs2aZbg7XU6ZmprSs2dPjh49yueff06XLl0oXbo0AH379iU5OZmpU6dy7do12rdvb3xecnIyYWFh2NraMmrUKCpVqmQsdLx4t77ssLS0pHr16lhYWLB582YsLCzw9vbO03lLz0tb0pe2VCvN9evXiY2Nfe3j5/T16dq1KwBbt27N8FjTpk357LPPcrVvt27dSEpKeundAGfPnk3NmjXTDYEHePLkSYbC4v9j787DoizXB45/Z0D23RU1E0gWR0wtNVLKFEoTFFFCE9JTudRBJY4lejpZai7lApr1czl5NDMXTolppmKaK6aejrlCirgChSyCywA6vz9q5jDswzag9+e6uJLhnfe9n+d9Nbi5n/s5efIk169f5/HHH8fZ2Vn3upWVFQUFBbrPPTw8WL58ucHXLu9+ZGZmkpSUVOr91VXVsVVn3qqqvsZa1evW1jNvCEluCSEqZaJUSuWWeODdvF9yIXIAACAASURBVHmTSZMm0adPHzw9PRttby2NRsP9+/cbxd/ZxhRrRWxsbPS2uzfEypUrKSoqIiYmBhcXF6ytrQkNDeW1116rUUwVJbfqc95rMjeN3cM8dtHwODs7M3PmTH744Qdyc3M5ceIEsbGxhIaG1tnmKOHh4QCsWLFCrzorKCgIW1tbVqxYwciRI/UqykxMTOjTpw/p6el8/PHHZGZmcufOHd3ukDXRvn174uLi+P333wkODkatVtfofGWZPXs2Tk5OREZGsmvXLvLz8zl16hR/+ctfaNWqVY3Pb+j8zJkzBxcXF9566y22bdtGXl4eV69e5c033yQtLU0vYWXosW5ubrz66qts376d3NxcsrKyWLZsGTNmzGD+/PmlEqT29vZMmzaNw4cPc+vWLY4dO0ZYWBhmZmbExsbqHdutWzeSk5O5cuUKhw8fJiUlBV9fX4OvXdb9OHPmDGFhYeVWkoeFhaFQKLh48WKV70tVx1adeauq6oy1NtT1M28ISW4JISolPbfEg27nzp14e3vz1VdfsWrVKr799ltat25t7LCqxdbWlgsXLpT5m9eGpjHFWle0yxi0TZe1li5dWqNtsytKbsm8C/HwefXVV3n33Xd57rnnsLa2rpdr+vj40KFDB9q1a8ezzz6re93S0pKhQ4cClFqSCLBhwwbGjRvHkiVLaN26NS4uLqxZs4aXX34ZAH9/f5588kndEvoTJ05w7do1FAoF7777rm55f/HXY2JiSExMpE+fPhQWFpKYmIiFhQVhYWG6Zcrx8fG6+MLCwkhMTCz1+rvvvgv8sWxu3rx5wB9VTdpKWDc3Nw4fPkz37t0ZNmwYLVu2ZNy4cUydOhUXF5daqdSs6vzAH43Kjx49SmhoKBMmTKBp06b06NGD7Oxs9u/fT7t27XTnNeTYFi1a8NNPPxEUFERERISuefjXX39NfHw8L730Uqm4bWxsWLJkCR988AHOzs4888wzODo68sMPP+g9HwAxMTF07twZLy8vQkNDiY2NxcvLy+Brl7wfLVq0YPTo0UyYMAFvb2/UajUKhYLXX39d9560tDRsbGz0xluZqo6tqrHXxrNX0Vgb2zNfVTWrNxVCPBSUJiayW6J4IN28eZO3336bFStWMGzYMJYuXVpmMkCIuhIcHMzq1auZMGECBw4cqLXfrjZr1gyFQiHPsxDCqMpblrRq1SpWrVpV5teaNWtWbpXWnDlz9D6fPHlymccNHz68zNfL69dVW68DuLu763YeLC4tLY1mzZqV+76qMmR+AJo2bcqiRYt0PbkqYsixTk5OLFiwgAULFlQe9J+8vLxKLV8ri4eHB/v27auVa5d3PwYOHFjqtZycHA4fPszIkSMNTspUdWxVif2pp56q1WevrLE2pme+qqRySwhRKaUsSxQPoB07duDt7c3mzZvZuHEjGzduNEoi4Ny5cwQFBWFvb4+1tTW+vr4cOHCg1HElG2AnJSXx0ksv0bRpU91rK1euLLNJdsn3pqamEhoaioODA02bNiUgIIALFy5UGmvJ5vAKhaJUxVFVVdTQW61W89577+Hp6YmVlRVOTk4EBgayZcuWGvf/S09Pr9LYb9y4QVRUFG5ubpiZmeHo6MiAAQP0tl/XVg3cunWLgwcP6sZiyJICNzc37OzsOHHiBIMGDaq1xuYmJiY4OjqWeqbra96rOjdVmefqHGuohvZcCCEap/T0dJycnCgsLNR7PTU1lQsXLuj1FxMNi0ajYeLEidjZ2TFz5kxjh9NoNKRnXpJbQohKybJE8SDJzc1l3LhxDBgwgJ49e3L69GmGDRtmlFjOnz+Pj48Px44dIy4ujoyMDD799FNmzpxZ6gfrkg2wx40bx5tvvsmVK1dITEzExMSk3CbZJV+PjIwkMjKSa9eusWHDBn744QdGjBhRabwjRowgKioKf39/srKy0Gg01e6nUFFD74iICBYvXsySJUu4ceMGZ8+exdPTk8GDB7N///5qXU+r+Ng3bdrE/v37S409PT2d7t27s27dOmJjY8nMzOTIkSNYWVnRr18/3XJBbeN9a2trevXqpWsQXtVmsHv27KFHjx7MmDGDwYMHs2fPHkJCQvTeHxAQoJeMMuRZbd68eankVn3Ne1XmpqrzbOix1dGQngshROOWnZ3NuHHjuHLlCrdv3+ann34iNDQUOzs7/vGPfxh0rjfeeMMoOw0/jDIyMkhJSWH37t313iuqsTPkmS++W3Btb1gmyS0hRKVMTEykcks8EL7//nu8vb2Jj49n06ZNbNy4sV7LpUuaNm0aOTk5xMbG4u/vj42NDd7e3qxatarSnZymTJlCnz59sLKyomfPnhQVFVV5LK+//jo+Pj5YW1vj5+fHwIEDOXr0KJmZmeW+Jycnh4EDB3Lv3j22b9+Oo6OjQWM1xO7du1GpVPj7+2NpaUnLli35+OOPcXd3r/G5i4+9b9++BAQElBr71KlTuXjxIjExMQQEBGBnZ4e7uzvr1q3D2dmZiRMnkpGRUaM4MjMzGTJkCL6+vkyaNIkNGzbQt29ftm7dSnh4uO7f3K1bt5KSkoKlpSVFRUXExcVV+RrNmjWjadOmVT6+Lue9LIbMc13fk4byXAghGrdWrVqRkJBATk6Oru/SoEGD6NChAz/99BOurq5VOk9YWJguMV5yp+HGpLy+aA1Rq1atOHDgACqVqkrHN6ax1SVDn/niuwVrNBoSExNrLRZJbgkhKlUXmXUh6lPxaq2nnnqKU6dO6ZrZGpO2N8MLL7yg93rr1q0rTSj06NGj2tft3r273uePPPIIANevXy/z+KSkJHr27IlSqSQmJqbOm4P279+fQ4cOMXbsWBITE3X//iQlJdGnT58anbvk2Nu0aQPoj13bN6Jkjwpzc3P69evHnTt32LFjR43iWLVqFbm5uYwcOVJ37vj4eHr06MH69esZP3687ti9e/fSu3dvg+fd1NTUoKVwdTnvZTFknuv6njSU50II0fj169ePr7/+mosXL6JWq0lPT2ft2rW4ubkZO7R6p61kLf4xa9YsY4dVKx7ksRmqoTzzktwSQlRKKrdEY7Z9+3Y6depEfHw8//73v41eraWlVqvJy8vDwsKizOUGLVq0qPD9Ndntyt7eXu9zMzMzgDL/nmdnZxMUFETbtm3Zvn07a9eurfZ1q2rp0qWsWbOGlJQU+vXrh52dHf379y+zWamhSo5duwW9duxqtZrc3FwsLCywtbUt9f6WLVsCpXc3NJS2ybL2fPDHbkva53XFihX87W9/4969e8TGxurt5FRX6nLeSzJknuvjnjSU50IIIYQQ1SPJLSFEpaShvGiMcnJyGDduHC+++CI+Pj6cPn2a4OBgY4elY25ujq2tLXfv3i1zuUFWVpYRoirN1NSUhIQE4uPj8fb2ZsyYMRw9erROr6lQKAgPD9eVuW/evBmNRkNwcDALFy6s02ubm5tjb2/P3bt3ycvLK/V17bKz4v04FAqFwdfRLhc8e/as3utOTk7s3LkTV1dXFi5cqFsqFxISYvA19u7da1BSrC7mvby5MWSeq3NPalt9PRdCCNGQXLp0iUGDBnHz5k3da7179y61uYz2IzIyslrXiY6OZsOGDbUVttGUNV8lrV+/XjdfFhYW9RhdxR6EeyDJLSFEpZRSuSUame+++45OnTqxZcsWvvnmGzZu3GhQ76H6MmDAAIBSW0dnZmaSlJRkjJBKsbW1pU2bNtjY2LBlyxZsbGwICgqqtCdYTTg4OHDu3DkAmjRpgr+/v26Xv23bttXZdbWGDBkCUOpaarWa3bt3Y2lpqbeU1MrKioKCAt3nHh4eLF++vErXWLRoEdnZ2Xpfc3Z2JiEhAQcHB44ePYqfn1+9JErqYt4rmhtD5tnQe1IX6uO5EEIYT35+Ph06dCAgIMDYoTQI//3vf3nyySd5/vnnsbOzq9NrjRkzhqlTpxrccL8hqep8DR8+HI1GQ79+/eoxuso9CPdAkltCiEpJ5ZZoLLTVWgMHDuTpp5/m1KlTBAUFGTuscs2ePRsnJyciIyPZtWsX+fn5nDlzhrCwsAa5M1L79u2Ji4vj999/Jzg4GLVaXWfXGj9+PL/88gtqtZrffvuNjz76CI1GUy9bSs+ZMwcXFxciIyPZunUreXl5JCcn8/LLL5OWlkZsbKzecsJu3bqRnJzMlStXOHz4MCkpKfj6+lZ4jZ49exIdHc2lS5fo3bs33333Hbdu3eL27dscPHiQd955B2traxwdHZk5cyarV682aAzHjx+nWbNm9O7d26B/v2t73iuaG0Pm2dB7Uhfq47kQQtQtGxsbevfuXebXNBoN9+/ffyi+561oHgBu3rxJYGAgQ4cOJSIiotTXjx49WqrflEajISYmplrxuLm58c033/Dhhx+ycePGap3DmCqbr8agsd8DkOSWEKIKlEol96WhvGjgtm3bRqdOnfj222/ZvHlzg63WKs7NzY3Dhw/TvXt3hg0bRosWLRg9ejQTJkzA29sbtVqNQqHg9ddfJzExEYVCQXx8PACWlpalqnm0VTbFjwkLCyvzvdodfRQKBfPmzQOga9euBAQE6Ermi+8AFBMTQ2JiIn369KGwsJDExEQsLCwICwur1tjLixXgxx9/xNPTk+HDh+Pk5ISXlxfff/89K1asYNq0aQZdx9Cxwx9Ly44ePcqIESOYOHEiTZs2pUePHty6dYuEhATGjBmjd42YmBg6d+6Ml5cXoaGhxMbG4uXlVWlsc+bMYevWrbRv355Ro0bh4OBAmzZtmDJlCj4+Ppw7d45t27ZhaWnJ6NGjdcsYioqKKj239geNkpuB1Ne8a1U0N4bMs6H3pDIN+bkQQhiHra0tFy5c4LvvvjN2KEb30UcfkZ6eznvvvVdv13z88ccZNmwYf/vb36r0/7nq6Nq1K/PmzePy5cu1el5jzFddqI97UJcUGo1GY+wghGiIFi2Cjz7WkHg6x9ihGF3MvHls27yZXYcPGzsU0QgN7W9Hbx8TqvnLvEplZ2cTHR3N8uXLCQkJ4f/+7/9wcnKqm4sJg61du5bw8HA+++wzvR0AhRB/MDU15cknn6zV7dCFqC2LFi1iwYIFXL161dih1AobGxu6dOnCgQMHjB2KUVU0DxqNBmdnZx577LEyv967d29iYmJ48sknaz2ur776ipdffpnNmzczePDgWj//iy++yM6dO7l//z7PPPMMI0eOJCQkBAcHh2qfs7L5Ko+fnx8HDhzg7t271b52Xajre1BT165do23bthw4cIBevXrpfUkqt4QQlVIqlaV++y9EQ7B161ZdtVZ8fDwbN26UxJYQQggh9MyfPx+FQsGtW7c4ePCgrhLW1NQU+F9Vq/ZDm3Ao+fqlS5cIDQ3F1taWpk2bEh4eTnZ2NqmpqQQGBmJra4uzszNjxowpc/OJ33//nYkTJ9K+fXvMzMxo3rw5wcHB/Pe//y117I0bN4iKisLNzQ0zMzMcHR0ZMGAAe/bs0R0za9YsXWzFlxl+//33uteL7xBd2TwAnDhxgoyMDB5//PFy5/OLL76gS5cuWFtbY29vj6+vL+vWrSt1nFqt5r333sPT0xMrKyucnJwIDAxky5YtZf5s0aVLFwB27NhR7rVr4rvvvuPq1avMnz+fmzdvMnbsWFq1akVwcDBff/11tdotVDZf586dIygoCHt7e6ytrfH19a0wCVaV+24IBweHcjcAUCqVpRLXdX0P6pIkt4QQlVIqldyXIk/RgGRnZzNu3DgCAwPp1asXp0+fZtCgQcYOS1TgjTfeQKFQNMheYkLUt+joaN0PF/LLIyHq3uTJk9FoNFhbW9OrVy/d0m3t0qugoCA0Gk2pSpWSr0dFRfHOO++Qnp5OTEwMa9euZeTIkURGRjJz5kzS0tJ4//33WblyJdOnT9c7V1paGt27d2fjxo18+umnZGVlsXfvXrKysvDx8eFwsRUS6enpdO/enXXr1hEbG0tmZiZHjhzBysqKfv36sXLlSgDeffdd3biK69+/PxqNhieeeMKgeQA4deoUAG3bti13PrOzs/n888/57bff+Omnn3BxcWHkyJFMnDhR77iIiAgWL17MkiVLuHHjBmfPnsXT05PBgwezf//+Uudt06aNXgx1oVWrVkRFRfGf//yHM2fOEBUVxfHjxxk6dCitWrVizJgx7N27l6oucKtovs6fP4+Pjw/Hjh0jLi6OjIwMPv30U2bOnMmFCxdKHV/V+26ovLw8vd5oM2bMAODDDz8sFXd93IO6IsktIUSlpOeWaEg2bdqEh4cHO3bsYOfOnWzcuBFHR0djhyXKERYWpvcNVX5+fq2ct7zfQhb/eP/992vlWuJ/Gvq8N/T4tObOnav390KWJArROLz22ms88cQTWFtbEx4ejkqlYvv27URFRdGlSxdsbGwYN24cLi4upXp3TZ06lUuXLrFw4UJefPFFbGxsUKlUrF+/Ho1Gw4QJE/SOvXjxIjExMQQEBGBnZ4e7uzvr1q3D2dmZiRMnkpGRUSdj1O6GbG9vX+bXDxw4wJo1a+jWrRvW1tZ4eHiwZs0aevTowZIlSzhy5Iju2N27d6NSqfD398fS0pKWLVvy8ccf4+7uXua57ezsUCgUdbojc3FeXl7Mnj2b1NRU9u7dy7Bhw4iLi+O5557TVTBVpqL5mjZtGjk5OcTGxuLv74+NjQ3e3t6sWrWqzDHWx33fuHEj06dPZ/To0UydOrXU1+v7HtQmSW4JISqlNDF5KHaOEQ3bb7/9RkhICKGhoQwZMoSTJ0/i7+9v7LCEkZS1S1PJj4aQxHjQNPR5b+jxCdHYmJmZUVhYaOwwSjl16lSpxHV97FJXss9U69aty3y9TZs2XL9+Xe+1zZs3o1QqdZtUaLVq1QqVSsXx48d1S8S++eYbAAYOHKh3rLm5Of369ePOnTt1tmxMuySzSZMmBr1v2LBhAHz77be61/r378+hQ4cYO3YsiYmJukrVpKQk+vTpU+Z5TE1NuXPnTjUir/5zoVAosLCwwMLCwuBxVzRf33//PQAvvPCC3uutW7cuM8FXF/c9JydHVzV/5MgRRo0axTPPPMOyZcvKfU9N7kFdKygoAP74t6kk01KvCCFECUqlUpJbwqg2bdrEm2++iY2NDTt37sTPz8/YIQkhhBAPPEdHR3Jycrh//z5KZcOpi+jUqVOVl43VJjs7O73PlUolJiYmWFlZ6b1uUuIXw2q1mtzcXKD8iiiAX3/9lebNm5Obm4uFhQW2traljmnZsiXwxxK2umBhYQFgcFLT2dkZ+OOXkVpLly7Fx8eH1atX069fPwB8fX0ZN24cQ4YMKfM8RUVFWFpaVid0g5+L5ORkvvzyS7788ksuXLiAg4MDQ4cOZeTIkeUm30oqb77UajV5eXlYWFiU2ZKhRYsWJCcn6x1fl/f98uXLDB48mEceeYSvv/66zOSQVk3uQV3LysoCKLPHbsP5F0oI0WCZmJjIskRhFBkZGQwbNozQ0FCCg4P55ZdfJLElhBBC1BMPDw8KCgo4f/68sUOpFQqFwijXNTc3x8HBAVNTUwoLC8utLH3uuecwNzfH3t6eu3fvltmUXrssrVWrVrrXlEqlrqKluJycsnd9r2getEkqbTKuqrSVai1atNC7Tnh4OAkJCeTk5LB582Y0Gg3BwcEsXLiw1Dlu3ryp232wrmRkZLB48WJ69OiBh4cHc+fOxdvbm7i4ONLT01m5ciXPPfdclZ+V8ubL3NwcW1tb7t69W2ZLBm2Spvjxht73qsrLyyMgIIDCwkK2bt1a4eZL9XEPauLs2bOYm5vz6KOPlvqaJLeEEJVSKBRSuSXq3aZNm+jUqRPHjx9n165dLFu2rMzfZAkhhBCibqhUKqysrNi3b5+xQ6kVVlZWekkgDw8Pli9fXi/XDg4OpqioiIMHD5b62rx582jXrp2usbu2qmnbtm16x6nVanbv3o2lpaXeUjdnZ2euXbumd2x6ejqXL18uM5aK5qFTp04ApXbRA1i5cmWpJvXwx5LwjRs3AhAYGKh73cHBgXPnzgF/LNvz9/fX7UBZcmyAbgzaGGrbwIEDadOmDZGRkVhaWrJs2TLS09P55ptvGDp0KObm5gafs6L5GjBgAPC/5YlamZmZJCUllTre0PteFffu3WP48OGcO3eOf//733rLIYcNG8bmzZv1jq/re1BT+/bto2vXrno7fGpJcksIUSkTExPuSXJL1JOMjAyGDh2qq9Y6efKkrpRdCCGEEPXHwsKCvn376noBNXbdunUjOTmZK1eucPjwYVJSUvD19a2Xa8+ZMwc3NzdeffVVtm/fTm5uLllZWSxbtowZM2Ywf/583Q/sc+bMwcXFhcjISLZu3UpeXh7Jycm8/PLLpKWlERsbq1umBvD8889z/fp1PvnkE/Lz87lw4QKTJk3Sq6Kq6jw8/vjjtGjRghMnTpT53v/85z/89a9/5fz589y9e5ekpCTCw8M5fvw4EyZMoGfPnnrHjx8/nl9++QW1Ws1vv/3GRx99hEajoW/fvqXO/d///lc3nrpw/fp1Zs2aRWpqKj/++CNjx46t8aZEFc3X7NmzcXJyIjIykl27dpGfn8+ZM2cICwsrc6miofe9Kt566y2+++47li9fXqWllnV9D2qisLCQb7/9tlRPMi1JbgkhKqVUKtFIckvUg02bNqFSqfj5559JSEhg2bJlZf7PXwghhBD1Y9SoUezYsYOLFy8aO5Qai4mJoXPnznh5eREaGkpsbCxeXl66aqL4+HgALC0tCQsLIzExsdTr7777LseOHUOhULBjxw7u3buHQqFg7ty5HDhwAIVCwY8//sitW7f0dmht0aIFP/30E0FBQURERNC8eXM8PT35+uuviY+P56WXXtLF2apVK44ePcqIESOYOHEiTZs2pUePHty6dYuEhATGjBmjN65Zs2bx+uuvM3v2bFq0aMHo0aN5++23adWqFTdu3EChUBAdHV3pPMAfKzZef/11jhw5Uqopfnh4OJs2bSItLY3+/fvj4OBAz549uXbtGuvWrWPx4sV6x//44494enoyfPhwnJyc8PLy4vvvv2fFihVMmzat1P355ptvaNOmTbnJi5r6+eefiY6Opl27drV2zormy83NjcOHD9O9e3eGDRumuzcTJkzA29sbtVqtez8Yft8rc/z4cZYsWQLAX/7yl1LN9v/973+Xek9d34Oa2Lx5M7/99hvh4eFlfl2hMUYnPiEagUWL4KOPNSSeLnut+sPky1Wr+GjmTE6kpBg7FNEIDe1vR28fE2Jiyj8mPT2dN954g/j4eMaMGcOCBQskqSWEEEI0AIWFhahUKrp168b69euNHY6oB7m5uahUKgICAvi///u/ernmiRMn6Nq1K+vWrWP48OH1cs3aYoz5qgsN+R4UFBTQuXNnHn/8cTZs2FDWIdekcksIUSlliR1fhKhN2t5av/zyC7t375ZqLSGEEKIBadKkCQsXLmTDhg3s3bvX2OGIemBvb8+3335LXFwcS5curfPrpaSkEBwczNSpUxtcUqUq6nu+6kJDvwexsbFcvnyZefPmlXuMJLeEEJVSKpWS3BK1Lj09naCgIEJDQxk6dCgnTpzgueeeM3ZYQgghhCghICCAF198kb/+9a9l7uQmHjxdu3bl2LFjbN++nZs3b9bptZYtW8aHH37Ihx9+WKfXqUv1OV91oSHfg6SkJGbNmsU777xD+/btyz1OliUKUQ5Zlvg/cevW8Y+33+ZsiV1YhKiKspYlbtq0ifHjx+Pg4MA///nPKjW4FEIIIYTxXL58mZ49e/LEE08QHx+PiYmJsUMS4qGkUCgqPWb69Om6fm+N2Y0bN/Dx8aFp06bs2bMHCwuL8g6VZYlCiMoppHJL1JK0tDQGDx7M8OHDGTZsGL/88osktoQQQohGoF27dmzevJkffviBSZMmITUSQhiHRqOp9ONBSGzdvn2boUOHUlBQwObNmytKbAFgWk9xCSEaMRMTE+5JckvU0KZNmxg3bhxOTk7s2bOHZ555xtghCSGEEMIAPXv2ZM2aNbz88stkZmayatUqLC0tjR2WEOIBc/36dQYNGsSlS5f44YcfaNmyZaXvkcotIUSllEolGkluiWoqLLjOt98OYvjw4YSEhPDLL79IYksIIYRopIYNG8aOHTvYtWsXffv2JTU11dghCSEeIIcOHaJnz57cvn2bxMREvL29q/Q+SW4JISolDeVFdWg0GtatXs3pkyqyss6yd+9eli1bhpWVlbFDE0IIIUQlrly5wv79+8v82nPPPcfhw4fJy8ujY8eOvPfee9y+fbueIxRCPEjS0tIYNWoUvXv3pnPnzhw6dAg3N7cqv1+WJQohKqU0MdGt365KA0Mhrl25wpSJE0k8eJDmLaIYNvQDfH0rXicvhBBCiPpVWFjIlStXOH36NGfOnCElJYXTp09z8uRJbt68iYmJCfn5+WX2unF3d+fnn39myZIlzJgxg3/+85+MGzeOl19+mccee8wIoxFCNDYajYbjx4/zr3/9i9WrV9OsWTPi4uIIDg42+FyS3BJCVEr5Z0Lr3r17mJrKPxuifBqNhq/WrOHDf/yDNm3b8u/vv2fGtD6yo5IQQghhRLm5uZw/f16XvCqeyLp79y4Azs7OqFQqVCoVISEhqFQqXF1dK2zi3KRJE6Kiohg5ciQLFy7kk08+Yfr06bi4uNCtWzdatWqFjY1NfQ1TCNFI5OTkcOnSJX7++WcyMjLo0KEDH3zwAW+88Ua1+/jJT6lCiEppExPSd0tU5Orly0yZNIkjBw8y5q9/5a3oaMzMzY0dlhBCCPHQyM7OLpW8OnPmDBcvXkSj0dCkSRMeeeQROnbsiJ+fH2PHjqVjx4506dKlRkmoli1bMm/ePD788EMOHDjAvn37OHnyJKdOnSI/P78WRyiEeBDY29vTunVrJk+ejJ+fH126dKnxOSW5JYSolEL5R3u+e/fv08TIsYiGR1etHW3E+wAAIABJREFU9e67tG3Xjn/v2MHjXbsaOywhhBDigVTeUsJffvmFvLw8ABwdHXF1daVjx46MHTtW92dPT886raY2NTWlT58+9OnTp86uIYQQZZHklhCiUtpvgqSpvCjpyqVLTJk0iZ8OHZJqLSGEEKIW5eTkcOHChVJLCU+dOoVarQbKX0ro6upq5OiFEKJ+SXJLCFEp5Z+VW/fv3TNyJKKhKFmt9fWOHXSWai0hhBDCYMWXEhZPYmmXEpqZmdG2bVvdUsKJEyeiUqnw9PTE2tra2OELIUSDIMktIUSldMktqdwSwOXUVKZMmsTRw4cZ89e/EjV1Kk3MzIwdlhBCCNFgGbqU0M/Pr96WEgohxINAkltCiEpJckuAfrXWI48+yjc7d+JdC80fhRBCiAdFWUsJT58+TVJSEvf+rIAvaymhSqXC2dnZyNELIUTjJcktIUSlZFmiuJyayjsTJ3LsyBHGvPmmVGsJIYR4qF2/fr3UjoQpKSmkpKQAYGZmxmOPPYZKpSIwMJApU6bIUkIhhKhDktwSQlRK11BeozFyJKK+3b9/n/VffMGsv/+ddi4ubN65k06PP27ssIQQQog6V95SwhMnTpCfnw+Uv5TQy8tL98tBIYQQdU+SW0KISin+/ObsnlRuPVQuXbzI2xMm8J+jR6VaSwghxAMrMzOTc+fOce7cOZKSkjhz5gxJSUmkpqZy7949TExMcHFxwdPTk6effpq//OUveHl54enpiZOTk7HDF0IIgSS3hBBVoKvckp5bD4Xi1VqPuroSv2sXqs6djR2WEEIIUW1FRUVcvHhRL4ml/fONGzcAsLa2xsPDA09PT0aPHo2npyeenp506NABc3NzI49ACCFERSS5JYSolPTcenikpqTwzsSJumqtv02bhmmTJsYOSwghhKgStVrN+fPndY3ctcsJz549y+3bt4E/lhJ27NhR1w9L++f27dvLUkIhhGikJLklhKiUQnZLfOAVFRWxYulSYubOxc3dnS0JCXT09jZ2WEIIIUSZsrOzS/XCOnPmDBcvXkSj0dCkSRMeeeQRXS+ssWPH0rFjRzp37oydnZ2xwxdCCFHLJLklhKiUiSS3HmjJ587xdkQE506fJjI6mrEREbqlqEIIIYSxFBQUcPXq1So3dB87dqzuz56envL/MiGEeIhIcksIUSmlJLceSNpqrUVz56Ly9mbbjz/ymLu7scMSQgjxkMnOztarvtL+OSkpiXv37mFqakq7du1wdXXliSee4JVXXsHV1RWVSoWzs7OxwxdCCNEASHJLCFEppTSUf+AknzvH23/9K+fOnOEtqdYSQghRx4qKirh8+XKpJNbJkyfJyMgAwNzcHDc3N10vrClTpqBSqfDy8sLKysrIIxBCCNGQSXJLCFEpbeXWPWko3+gVr9bq1Lkz3+3bh1uHDsYOSwghxAMiJyeHCxculFmJdffuXUC/obufn5/uzy4uLigUCiOPQAghRGMkyS0hRKVkWeKDIensWd6OiCD57Fmp1hJCCFEj169fL9XMPSUlhZSUFADMzMxo27ZtqYbuXbp0wcbGxsjRCyGEeNBIcksIUSltAuS+VG41StpqrYVz5tC5Sxe+27cP18ceM3ZYQgghGji1Ws358+dLJbHOnTvHrVu3AP2G7n5+ftLQXQghhFFIcksIUSntEgGp3Gp8zp05w9sREfx67hxRU6dKtZYQQohSsrOzSy0hPHPmDKmpqdy/f1+voXuvXr10uxJ6e3vTsmVLY4cvhBBCSHJLCFE5E2ko3+gUFRay4tNPddVa2/fvx8XNzdhhCSGEMJLCwkKuXLlSKol18uRJbt68CYCDgwNubm64uroSHh6OSqXS7UpoYWFh5BEIIYQQ5ZPklhCiUtJzq3E5d/o0kyMiOJ+URNTUqYybMEF3D4UQQjzYMjIyOHv2LMnJySQlJXHu3DmSkpJITU3l3r17KJVK2rdvj4eHBz179uSVV17Bw8MDLy8vWrRoYezwhRBCiGqR5JYQolJKqdxqFIpXaz3etatUawkhxANKrVbrklfJycm6BFZSUhK5ubkA2Nra4uHhgbu7O6NHj8bDw0P3YW5ubuQRCCGEELVLkltCiEppq37uSUP5BuvsqVNMjogg5ddfpVpLCCEeENnZ2aV2Izx9+jRJSUm6/yc7OzujUqno0qULwcHBdOzYEZVKhYuLi65nphBCCPGgk+SWEKJS2iSJRiq3GhxttdaC2bPp9uSTfLdvn1RrCSFEI1JQUMDVq1cr7IVlbm6Om5sbKpWKwMBApkyZgkqlwtPTE2trayOPQAghhDA+SW4JISplIj23GqQzJ08yOSKCi+fP87dp06RaSwghGrCSOxJWVIWlUqkICQnRNXSXKiwhhBCiYvJTkBCiUgpZltigqNVq5n3wAYF9+2JjY8P2/ft5Y9IkSWwJIYSRFRQUkJKSwrfffsu8efMYN24cvXv3xt7eHicnJ3x9fXnnnXdISEgAIDAwkM8//5zZs2cDkJaWxv79+1m2bBmTJk3Cz88PV1fXeklszZ8/H4VCgUKhoG3btjU619q1a3XnUigU2NjY1FKUVbN582a969+9e7der18VR44cITAwkNatW2NnZ8fTTz9NbGwsWVlZ1T7nxo0bUSgU0lOtHMZ+LqKjo/Wu/9RTT9Xr9YV40EnllhCiUibahvIajZEjET8fO8bbERGkp6Uxc/58Rrzyivw2Xwgh6lnJKiztn1NTU3VVzoZWYU2dOhU/Pz8OHDhgcDz5+fl07doVDw8Ptm7dWq0xTZ48mcmTJ9OlSxcyMzOrdY6SPvvsM8aPH6/3Wm3EWpmgoCA0Gg1BQUHEx8fXyTVq4uDBg/Tp04fnn3+egwcP0qJFC7Zu3cqoUaM4efIkK1eurNZ5mzdvrvff4upj3hs6Yz8Xc+fOZe7cuQCYmsqP4ULUNvlbJYSolLYi6L5UbhmNWq0mZu5cln/yCU8/8wxr4uJoXcPfrAshhChfQUEBv/76a6llhL/88gt5eXkAODg44ObmhqurK+Hh4boElpeXF1ZWVvUWq0aj4f79+42ifUBjirUiNjY2dOnSpVrJyJUrV1JUVERMTAwuLi4AhIaGsm/fPtRqdbVjqii5VZ/zXpO5aewe5rELYWyS3BJCVEqprdxq5N+INlb/OXqUtyMiyEhPl2otIYSoZZVVYZmamtKuXTtcXV1LVWG5uroaO3wAbG1tuXDhgrHDqJLGFGtd0fxZCZ+enk6HDh10ry9durRG560ouSXzLoR40ElySwhRKaX03DKKu3fvEjtvHss/+YRezz7L2q+/xrlNG2OHJYQQjY5areb8+fOlElhJSUnk5+cD4OjoqEtYFa/C6tixI5aWlkYegXiQBAcHs3r1aiZMmMCBAwdqrSdZs2bNUCgUZSa3hBDiQSfdh4UQlVL+WSWkkcqtevOfo0d58ZlnWLtqFTPnz2f1pk2S2BJCiEpcv36dhIQEli9fTnR0NIGBgbi5uWFlZUWnTp14+eWXWb58OWlpafTq1YsFCxawa9cuLly4QFZWFseOHWPjxo28//77hISE8MQTT9RJYuvcuXMEBQVhb2+PtbU1vr6+ZS5jKtkAOykpiZdeeommTZvqXlu5cmWZTbJLvjc1NZXQ0FAcHBxo2rQpAQEBVarkKdkcXqFQkJ6eXq1xV9TQW61W89577+Hp6YmVlRVOTk4EBgayZcuWGv9yLT09vUpjv3HjBlFRUbi5uWFmZoajoyMDBgxgz549umO0jfdv3brFwYMHdWMxpIeSm5sbdnZ2nDhxgkGDBtVaY3MTExMcHR1LJbfqa96rOjdVmefqHGuohvZcCCFqRpJbQohKybLE+nP37l3mffABIS++yCOPPsrOgwd5edQoWYYohBB/UqvVnD59mk2bNjFv3jxeeeUVnnzySWxtbWnTpg3+/v5ER0eTkJCApaUl4eHhrF+/nmPHjpGXl8eFCxfYtWsXsbGxjB07VrcjYX05f/48Pj4+HDt2jLi4ODIyMvj000+ZOXNmqR+stQ2wBw8eDMC4ceN48803uXLlComJiZiYmJQ6prz3RkZGEhkZybVr19iwYQM//PADI0aMqDTeESNGEBUVhb+/P1lZWWg0Glq1alWtsZcXK0BERASLFy9myZIl3Lhxg7Nnz+Lp6cngwYPZv39/ta6nVXzsmzZtYv/+/aXGnp6eTvfu3Vm3bh2xsbFkZmZy5MgRrKys6Nevn67J++TJk9FoNFhbW9OrVy80Gg0ajYaioqIqxbJnzx569OjBjBkzGDx4MHv27CEkJETv/QEBAXrJqGHDhlV5rM2bNy+V3Kqvea/K3FR1ng09tjoa0nMhhKg5SSULISqlW5Yoya06dfynn3g7IoLff/uNmfPn8/KoUcYOSQghjKKoqIiLFy+SlJREUlISycnJ/PrrryQlJXH9+nUAmjRpgpubG56envj5+fHmm2/i6emJh4cHTZs2NfIIyjdt2jRycnJYuXIl/v7+AHh7e7Nq1apKk2xTpkyhT58+APTs2dOgH5xff/11fHx8APDz82PgwIHExcWRmZlJs2bNynxPTk4Ow4cPx9PTk+3bt+t2T64Lu3fvRqVS6ebE0tKSjz/+mC1bttT43MXH3rdvXwICAli3bp3e2KdOncrFixf56quvCAgIAMDOzo5169bh6urKxIkTCQwMpGXLltWOIzMzkyFDhuDr68ukSZMYP348L774Ilu3biU8PJwvv/wSpVLJ1q1buXjxIiqViry8PIPmvVmzZgY9/3U572UxZJ7r+p40lOdCCFE7pHJLCFEppVKJQqGQyq06Urxa61EXF3YeOiSJLSHEQyE9PZ0ff/yRFStW8PbbbzN48GA8PDywsrLC3d2dwMBA5s+fT3JyMo899hhvvfUWW7ZsITk5mdu3b3P27Fm++eYb5s6dy6uvvsrTTz/doBNbAN9//z0AL7zwgt7rrVu3xt3dvcL39ujRo9rX7d69u97njzzyCIAuWVhSUlISPXv2RKlUEhMTU6eJLYD+/ftz6NAhxo4dS2Jiom5JXFJSki6hV10lx97mz2X+xcf+zTffADBw4EC9Y83NzenXrx937txhx44dNYpj1apV5ObmMnLkSN254+Pj6dGjB+vXr2f8+PG6Y/fu3Uvv3r0NnndTU1ODlsLV5byXxZB5rut70lCeCyFE7ZDKLSFElSiVSu5LQ/ladzQxkXcmTOBGZiazFiyQpJYQ4oFTspm7tqH7qVOnyM3NBf74QdHNzQ2VSsWQIUN0jdw7d+6MnZ2dkUdQe9RqNXl5eVhYWJTZRLxFixYkJyeX+35ra+tqX9ve3l7vczMzM6DslgPZ2dkEBQXRtm1btm/fztq1awkLC6v2tati6dKl+Pj4sHr1avr16weAr68v48aNY8iQITU6d8mxayvStWNXq9Xk5uZiYWGBra1tqfdrq3Kq22tMS3tvi1f52NjYsH37dp599llWrFiBra0tH330EbGxsUybNq1G16uKupz3kgyZ5/q4Jw3luRBC1A5JbgkhqkShVErlVi26c+cOiz/6iGVLlvBsv358tWULrZydjR2WEEJUS1FREZcvX9ZLXmmTWampqdy/fx9TU1PatWuHq6srKpWKkJAQ3Y6E7du31/1g+SAzNzfH1taWvLw88vPzSyW4srKyjBSZPlNTUxISErC3t+fpp59mzJgxeHh4lKp0qU0KhYLw8HDCw8MpLCxk7969zJ8/n+DgYBYsWEBUVFSdXdvc3Bx7e3tyc3PJy8srlcjIyMgA0Os1Vp1emNqqwrNnz/L888/rXndycmLnzp307t2bhQsXsn//fqytrQkJCTH4Gnv37jXo+LqY9/LmxpB5rs49qW319VwIIWrHg/9dhBCiVpgolTXerUj84WhiIgOeeYYv//UvZi1YwKoNGySxJYRoFLKzszl+/Dhr1qwhOjqal156iSeffBI7Ozvc3Nx0zdwPHjyIs7MzY8eO1TVzv3nzpq6Z+7Jly5g0aZKumfvDkNjSGjBgAPC/5YlamZmZJCUlGSOkUrTN+W1sbNiyZQs2NjYEBQWRlpZWZ9d0cHDg3LlzwB/91Pz9/XW7/G3btq3OrqulrVIqeS21Ws3u3buxtLTUW0pqZWVFQUGB7nMPDw+WL19epWssWrSI7Oxsva85OzuTkJCAg4MDR48exc/Pr14SJXUx7xXNjSHzbOg9qQv18VwIIWqHVG4JIapEqVSikcqtGilerfWcvz8bvv2WlnX4G0chhKgOtVrNtWvX9KqvKlpG6Ofnx9ixY+nYsSPe3t6llvoIfbNnzyYhIYHIyEjs7e3x8fHh8uXLREVFYWNjo5vjhqJ9+/bExcXh7+9PcHAwe/fuxdzcvE6uNX78eBYvXoyHhwe5ubl89tlnaDQa+vbtWyfXK27OnDn8+OOPREZGYmNjw7PPPktaWhpTp04lLS2NZcuW6S0n7NatG4cPH+bKlStcvXqVlJQUfH19K7xGz549iY6OZu7cufTu3ZuPP/6YZ599FoVCwc8//0xMTAzW1tYoFApmzpyJq6srowxoV3D8+HFeeOEFPD092bdvX5WTxrU97xXNjSHzbOg9qQv18VwIIWqHJLeEEFWiVCq5r9EYO4xG66fDh3lnwgSys7Kkt5YQokG4fv16qT5YZ86c0S0jhD+qSVQqFSqVisDAQDp27IhKpXpolhHWBTc3Nw4fPsyUKVMYNmwYhYWFdOrUienTp7No0SJ2796NQqHgtdde09vNDf7YyQ5AU+z/x5s3b9brjWRpacnIkSOJiIgo9d6///3vzJo1S68iqGvXrgwcOJCwsDBGjBihe12hULBo0SKeeuopXWPxxMRELCwsGDlyJGvXrjV47OXFunbtWn788Uc+++wzhg8fzqVLl7CwsMDd3Z0VK1bw2muvGXSdxMREg8a+detWWrVqxdGjR5k1axYTJ07k6tWrWFlZ8dRTT5GQkFAq0RMTE8OYMWPw8vLCycmJ2NhYvLy8Ko1tzpw59O7dm08//ZRRo0aRk5ODjY0NKpWK4OBgVq1axcmTJ/Hz82P06NGMHj0agMLCwkobxWs0GjQaTalK+/qad62K5saQeTb0nlSmIT8XQoiaU2g08tOqEGVZtAg++lhD4ukcY4fSIHi3b8+0GTMY8corxg6lUcnPy2P2e+/x1Zo19H3+eWYvWvTQVWsN7W9Hbx8TYmKMHYkQD5/s7Owy+2CdPXuW27dvA+Do6Iirq6uuibu2D1bHjh11yRQhDLF27VrCw8P57LPP9HYAFEL8wdTUlCeffJLExERjhyLEg+KaVG4JIapEliUabv+ePUyZNAm1Ws0nn3/OwMGDjR2SEOIBVFBQwNWrV/WSVykpKZw8eVLX8NjMzIy2bdvSsWNH3TJCV1dXvL2963xZjxBCCCFEXZPklhCiSkxMTKShfBUVr9Z6cdAgZn78MU7Nmhk7LCFEI2fIMkJXV1f8/PxkGaEwqjfeeIM33ngDa2tr8vPzjR2OEEYVHR3NvHnzjB2GEA8sSW4JIapEoVTqfngS5dv3ww9MmTSJgoIClq5axYuDBhk7JCFEI2LoMsLw8HBdMsvLywsrKysjj0AICAsLIywsrNbPW5XdA6dPn877779f69d+mDX0eW/o8WnNnTuXuXPnGjUGIR5kktwSQlSJiVIplVsVyLt5kznTp/+vWmv+fJyaNjV2WEKIBigvL4/z58/z66+/8uuvv5KcnExSUhLJyclkZ2cDf2wn36FDB9zd3enfvz+TJk3Cw8ODDh064OjoaOQRCGEc0irYOBr6vDf0+IQQ9UOSW0KIKlEqlfLNQzl+3L2b6MhICgsK+Oxf/6J/YKCxQxJCGNndu3d1yatff/1Vl8xKTk4mLS0N+GO596OPPoq7uztPPfUUr7zyCu7u7ri7u/PII49UqRpBCCGEEEJIcksIUUWyLLE0bbXWutWrGTh4sFRrCfGQKSws5MqVK7plhMWXEl66dElX7ero6KjrfTVgwADdkkJZRiiEEEIIUTskuSWEqBJpKK9vb0ICUyMjKSwsZNmaNbwQEGDskIQQdaRkI3dtEis5OZmioiKg/D5YHh4e2NjYGHkEQgghhBAPNkluCSGqRKlUopHKLW7m5jL3/fd11VqzFizA0cnJ2GEJIWooOztbr4G79qO8Ru6BgYG6aqwOHTpgZ2dn5BEIIYQQQjy8JLklhKgSpVRusWfXLqZGRnLv3j2Wf/EFzw8caOyQhBAGKG8nwqSkJPLz8wGwsLDA1dUVlUqFn58fY8eOxdXVlU6dOtGqVSsjj0AIIYQQQpTFoOTW+vXrGTFiBADm5ubcvXu3ToKqyPz583n77bcBaNOmDVevXq32udauXUt4eLjuc2tra903t/Vh8+bNDBkyRPf5nTt3sLCwqLfrV8WRI0eYNWsWx48fJz8/n06dOhEaGkp4eDhO1axW2bhxI6GhoZiZmaFWq2s54sZv57ZtjC32XCalpWFubl5v15/3wQd8Fhur+7zLE0+wedculArFQ9tzq2S11ocLF+Igu5UJ0SAVT2AVT2L9+uuv3Lx5E/jje5g2bdrQsWNHvQSWq6srLi4u0shdCCGEEKKRMSi5NXz4cIYPH46fnx8HDhww+GL5+fl07doVDw8Ptm7davD7ASZPnszkyZPp0qULmZmZ1TpHSZ999hnjx4/Xe602Yq1MUFAQGo2GoKAg4uPj6+QaNXHw4EH69OnD888/z8GDB2nRogVbt25l1KhRnDx5kpUrV1brvM2bN9f7b3H1Me8N3fMDB5KalcWYsDB2ffddvV9/yvTpTJk+HQC3YvdI+ZA2lN+9YwfT3noLjUbDirVr8X/xRWOHJMRD7+7du1y4cKHUEsJTp06Rnp4OgJmZGW3btsXV1ZUnnnhCrw9W+/btUSqVRh6FEEIIIYSoLfW6LFGj0XD//v1G8QNyY4q1IjY2NnTp0qVayciVK1dSVFRETEwMLi4uAISGhrJv374aVVxVlNyqz3mvydw0dh3btqWjtzdx27dX+T0mJiZoNJo6jKphyc3JYd4HH0i1lhBGolaruXbtWpl9sC5evIhGo8HU1JR27drpqq78/Px0fbAeffRRTExMjD0MIYQQQghRD+o1uWVra8uFCxfq85LV1phirSvaREZ6ejodOnTQvb506dIanbei5JbMe8OlUCofmp5bCd9/z9+jotBoNKxctw6//v2NHZIQD6SCggKuXr1aZh+s1NRU3S86nJ2ddVVXfn5+umSWSqVqcMv5hRBCCCFE/ZOG8qJcwcHBrF69mgkTJnDgwIFa28q8WbNmKBSKMpNbouEyMTFp9JWMlbnx++98+N57fL1hAwMHD2b2okXYOzgYOywhGrWioiIuX75cZh+sS5cu6ZLm2p0ItX2wtAksLy8vrKysjDwKIYQQQgjRkFXYcOLcuXMEBQVhb2+PtbU1vr6+ZS7h2rx5MwqFQveRlJTESy+9RNOmTXWvrVy5Uu8YbTP6ku9NTU0lNDQUBwcHmjZtSkBAQJUqedauXat3HoVCoeu7YaiSMRVvnK9Wq3nvvffw9PTEysoKJycnAgMD2bJlS42rWtLT06s09hs3bhAVFYWbmxtmZmY4OjoyYMAA9uzZoztm/vz5KBQKbt26xcGDB3VjMTWtej7Tzc0NOzs7Tpw4waBBg2ptAwETExMcHR1LJbfqa96rOje3bt0g7+bfeKZbNx5r2ZLOLi6MCgnh8P79pc6ZnZXFzL//vUrHGur3jAwiXn0V7/bt6eLmxqvDh3Pp4sVqxbD8k09o7+TE7du3OXbkCO2dnGjv5KTXWwtg4Zw5dHr0Ue7du8cv//0vqnbt+DUpic8/+wxVu3a4Nm+ue+8uA5Y2NmTb4uPx79WLI4cO8cXXX7N01SpJbAlRRYWFhSQnJ/Pdd9+xePFiJkyYwIABA+jQoQOWlpa4ubnh7+/Pe++9x6FDh2jRogVjxoxhw4YNnDhxgtu3b5OVlcWxY8dYs2YNU6ZMISQkhCeeeEISW0IIIYQQolLlJrfOnz+Pj48Px44dIy4ujoyMDD799FNmzpxZKuGibYw+ePBgAMaNG8ebb77JlStXSExMxMTEpNQx5b03MjKSyMhIrl27xoYNG/jhhx90OzRWZMSIEURFReHv709WVhYajabaW3aXFytAREQEixcvZsmSJdy4cYOzZ8/i6enJ4MGD2V/DREbxsW/atIn9+/eXGnt6ejrdu3dn3bp1xMbGkpmZyZEjR7CysqJfv366Ju+TJ09Go9FgbW1Nr1690Gg0aDQaioqKqhTLnj176NGjBzNmzGDw4MHs2bOHkJAQvfcHBAToJaOGDRtW5bE2b968VHKrvua9KnOTnp7OokXduXNnHdPnzOG/588Tn5CApZUVLwcFsf6LL3TH/v7bbwzq14/4uLhKj62OD6ZN49U33uDImTN8umoVPx0+zMTXX9c7pqoxjI2IIDUrCysrK57s2ZPUrCxSs7K48Pvveufr3acP+Xl5ANy/d49b+fkUqNXcvXuXW/n53P8zoWhlbc2zffvWaHx1Sa1Wc+fOnQqPufH777w5ejQRr75K/4ED2XnwIL59+tRPgEI0IgUFBSQlJbFt2zZiYmKIiIigf//+uLm5YWVlhYeHBwMHDuTDDz/kP//5Dy1btmTUqFF88cUXHDt2jNzcXNLT09m3bx///Oc/iY6OZujQoXTu3BlLS0tjD08IIYQQQjRi5ZbxTJs2jZycHFauXIm/vz8A3t7erFq1CldX1wpPOmXKFPr8+cNhz549q5xQAXj99dfx8fEBwM/Pj4EDBxIXF0dmZibNmjUr8z05OTkMHz4cT09Ptm/fXqcNZHfv3o1KpdLNiaWlJR9//DFbtmyp8bmLj71v374EBASwbt06vbFPnTqVixcv8tVXXxEQEACAnZ0d69atw9XVlYkTJxIYGEjLli2rHUdmZiZDhgzB19eXSZMmMX78eF588UW2bt1KeHg4X346PjNhAAAgAElEQVT5JUqlkq1bt3Lx4kVUKhV5eXkGzXuzZs1o2rRplY+vy3kvy9SpU8nKuoiDwzr6vfACADa2tixevhzfrl15f8oU/Pr3p1nz5sybMYMrly6xZOXKSo+tjuHh4XTr3h2Ap595hn4vvEB8XBxZN27g9Occ1nYM3Z96ilatW5N+/Xq5x5g2acKAwEDMzM2rNa768H50NBYWFkyfM6fMr2+Lj+cfkydjZW3NF19/Te9nn63nCIVoWAoLC7ly5UqVlxC6uroSEhKiW07o7e2Nvb29kUchhBBCCCEeNuVWbn3//fcAvPDnD8parVu3xt3dvcKT9ujRo9oBdf/zh3itRx55BIDr5fyQnZSURM+ePVEqlcTExNT5zkj9+/fn0KFDjB07lsTERN03+klJSbqEXnWVHHubNm0A/bF/8803AAwcOFDvWHNzc/r168edO3fYsWNHjeJYtWoVubm5jBw5Unfu+Ph4evTowfr16xk/frzu2L1799K7d2+D593U1NSgJZJ1Oe9l0c6zuYX+PJuZm9Pr2We5e/cuP+7eDcCOrVsB6Pv885UeWx2Pd+um93krZ2cAfiu27La2Y1AoFAyrpGKyqLCQQUOHVvmc9S0+Lo6vVq/mX8uXczQxUe9rmb//zvhRo/6o1goIYMeBA5LYEg+NgoICUlJSSEhIYPny5URHRxMYGIibm5veEsLo6GgSEhKwtLQkJCSEzz//XFeBpV1CuHHjRubOncvYsWPp3bu3JLaEEEIIIYRRlJldUKvV5OXlYWFhUWYT8RYtWpCcnFzuSa2trasdUMlvjM3MzADKbGSdnZ1NUFAQbdu2Zfv27axdu5awsLBqX7sqli5dio+PD6tXr6Zfv34A+Pr6Mm7cOIYMGVKjc5ccu1L5R+5RO3a1Wk1ubi4WFhbY2tqWer+2Wqu6vca0tPe2ePWXjY0N27dv59lnn2XFihXY2try0UcfERsby7Rp02p0vaqoy3kvSTvPpqYWKBS2QI7e17XVT7//9hsFajV5N29ibm6OdRl/V4ofW122dnZ6n5d8LuoqhiEvvcQnCxaU+3VrGxue9vU16Jz15eKFC0RHRqJQKFAqlUx8/XUSjhzB2tpar1pr7ddf00uSWuIBVNEuhOVVYIWHh+t2JOzQoQN2Jf7tEUIIIYQQoqEqM7llbm6Ora0teXl55Ofnl0pwZWVl1UtwlTE1NSUhIQF7e3uefvppxowZg4eHR6kKqNqkUCgIDw8nPDycwsJC9u7dy/z58wkODmbBggVERUXV2bXNzc2xt7cnNzeXvLy8UgmujIwMAL1eYwqFwuDraJcLnj17lueLVQI5OTmxc+dOevfuzcKFC9m/fz/W1taEhIQYfI29e/cadHxdzHt5c1N8njWavFJfz/yzP1XzFi0wMzfH1s6OvJs3uZWfXyq5VPzYulKdGKryXLh16AAKBWg0pb5mampK4JAhNPkz+dyQ3L17l7FhYRQWFKDRaLh37x6//fYbs/7+dzJ//53dO3YQ/tprTJk+XRpVi0ZNrVZz7dq1UsmrlJQUUlNTdQnw8hJY7u7uZf6iRAghhBDi/9m79/gc68eP4+975/OJYcbMmZSinHIscyZL4itUIitRo+SQDiKHVJsOTikd5FAKIUJHiRAlp7FpjnPabHY+2P37I+6f2Yax7dq9vZ6Pxx5t130d3velW9+9v5/P5wKsTb7TErt06SLp/6cnXnbu3DlFREQUbaob5O7uLn9/f7m5uenbb7+Vm5ubgoODFRMTU2TX9PLy0oEDByRJ9vb26tChg+Upf2vWrCmy6152eZTS1ddKT0/XDz/8IGdn5xxTSV1cXJSRkWH5uW7dupo3b94NXSMsLEznz5/P8Zqfn582btwoLy8vbd++XUFBQTdVoBVUUdz3a92by/cgPS3nuTPS07X5l1/k5OSktpdGkHW6tPbZj+vXX3ffolLQDE4uLsq84r3f16SJFn36aa7zXn5YwNWysrLUo1evwopfqF4aNUr/RkXlWOvvYlaWlnz+ufbv3asvli/XxOnTKbZgFdLT0y1TCGfOnKmQkBB16NDBsoj75SmEEydO1J9//ik/Pz8NHTpUS5Ys0Y4dO5SYmJhjCuFrr71meQohxRYAAABKi3wXPZoyZYo2btyo0NBQeXp6qkWLFjp69KhGjRolNzc3JSQkFGfO6woMDNSyZcvUoUMH9erVSz///LMci2ih66eeekrvvvuu6tatq4SEBM2ePVtms1n3F8NT46ZOnapffvlFoaGhcnNzU9u2bRUTE6Nx48YpJiZGc+fOzTGdsHHjxtqyZYuOHTtmmaLS+jpTyZo1a6axY8dq2rRpatWqlWbMmKG2bdvKZDJp165dCg8Pl6urq0wmkyZNmqQaNWroscceu+H38Oeff6pTp06qV6+efv31V8s0u+sp7Pt+rXszdepUffvtL4qPH6kfvjepecuWOnP6tKa//rrOnD6tKWFhlul+Y155RX9s3qyJ48bJxdX1mvsWlYJmuL1hQ+3cvl0xJ04o5uRJHTtyRE0vPczgSiaTKc8pwR6enmrWsmWRvqebsXThQn29ZEmer9nY2MgkqVERjuwEbsblEVhXj77KawTWbbfdpgYNGigoKMgyGqtevXq3tBwAAAAAYO1MZnMec44uOXjwoMaMGaMff/xRmZmZuv322/Xqq68qLCxMP1xanHrw4ME5nvJ3pStPvWLFilxrI/Xv31/Dhw/PdexLL72kyZMn5xox0q1bNw0YMED9rlroOiwsTM2bN891nv79+2vhwoX5vvmFCxdq4MCBmj17do5F0vPLunDhQv3999+aPXu2fv31Vx05ckROTk6qU6eOBg8erMGDBxdoFNPWrVsL9N5XX1o0PDY2VpMnT9bKlSt1/Phxubi4qHnz5nrxxRdzFT0RERF68skntXPnTvn4+Gjs2LEaNmzYDeVbs2aNZs2apW3btik+Pl5ubm5q0KCBevXqpaFDh+qff/5RUFCQUlJSLMdkZmZed6H4HTt2qFOnTqpTp442b95sKbeK675fdr17M3lyrKZNmyyf8ssVc/KknJ2d1eiee/TUs8/q3jZtcpzrfFyc3nv7bW347rvr7ns9u3bs0INXLQw//Pnn9cJLLynQxyfH9vs7dtTHl8qcgmQ4HBmpsc89pz1//y1Pb28NCw3VwMGDc2Wp6esrF1dXpSQnW9bosbO31/8GDtTkt94q0PsqahH796vH/fcrIz09333s7Ow06Kmn9NLrrxdjMjzU2UOtWtgqPNzoJMZJS0tTVFRUrvLq8OHD+vfffy3/vfTz87NMG7zyiwILAAAAyNeJa5ZbpV1+5RYgSWFh0pszzNq6N/76O5dSNX19VSUgQEejo3OU1UtXrSpRI7eSk5LUpU0bnTx+PMd0xLzY2Nho2dq1aswIrmJTVsqt+Ph4RUVF5SqvbrTAql+/PtNlAQAAgII7ce0hNgDKPE8vLzk6OSktNVWS5O3jo3uaNzc4VU4vPvvsDRVbl6dZjh4+XN/9+muRTV1G6XXu3DlFRkYqKipKUVFROnTokCIjIxUZGalz585J+m9dwGrVqqlWrVqqV6+eevTooVq1aql27doKDAyUvb29we8CAAAAKF0otyQ9/fTTevrpp+Xq6qqkpCSj4wCGmj5xombPnGn52cbGRl169NCq5ctlktSzd2/Z2toaF/Aqn3/0kb5buVJ5DUI1mUyys7dXZkaGHBwd1fiee9S8VSvd07y5bG9wrTeULWazWcePH7eUV1FRUTnKrMvrTTo4OCgwMFC1atVS06ZN1b9/f9WqVUu1atVSYGDgdadnAwAAACg8ZXpaYlG5kfWfXn31Vb322mtFH6YMKez7XtjTEq9eLysvoWPGKHTMmEK5XmHa9PPPGnjp6YhfffedmpSQkVv//PWXHuzYMceILTs7O2VlZcnBwUGNmzRR6/vuU/NWrXRn48YUDgYpadMSMzMzdezYsTynD0ZERFj+Tw5HR0f5+/vnmDp4eUH3gIAA/n0CAAAASgamJRYF+kJjlPT7Hh0Xl+f22LNntfuvvxR16JAuJCRo+sSJxZzs+sxms5ydnWUymfTDunX68fvvjY6k9PR0ffnFF5Ziy8bGRn7+/rq9YUO179xZPR96SI5OTganhFEyMjIsT0G98mvv3r06ePCg5d8bb29vS3EVFBSkoUOHWn4ODAy84ae5AgAAADAO5RZggOTkZC1fulRfL1miv3fuVHZ2tir7+8vH21sOJXQdKA8PD5klbdu82egokqR/Dx+W2WxWJT8/ubu7y9XVVYmJifr1xx/1/Zo1evP119Wpe3cNGDRI9W+/3ei4KALnz5/Pc/TV4cOHFR0drezsbEk5C6wePXpYvm/QoIH8/PwMfhcAAAAAbhXlFlCMzGazvlmyRNNff12JFy6oT58+eu3ll9WmTRt5eXkZHe+adu3apczMTDVt2tToKMrIyFBmZqZcXV1zvXbx4kXt3btXa9eu1YJPPtGiTz5Rz969Nfa111SJIsPqXKvAOnz4sGW/K59AGBQUZCmw6tSpI3d3dwPfAQAAAICiRrkFFJOoQ4f0wjPP6J+//lJISIgmTpyocuXKGR3rhjVq1KjETP10cHCQg4NDnq/Z2tqqYcOGatiwoV588UWtWLFCz7/wgto3bapR48dr8NNPF3NaXM/58+e1d+9e7du3L0dxdejQIV24cEHSf3/mVapUyTGF8Mp1sJydnQ1+FwAAAACMQrkFFIPffvlFzzz+uOrVq6edO3fqjjvuMDrSTbmRRftLEpPJpAcffFBdunTRW2+9pYmvvqq9u3drWnh4iZ3+WRqZzRlKSIjRxo25R17t379fKSkpkiQnJyfLdEHWvwIAAABwo3haIpCPwnpa4pdffKHxI0eqb9+++uijj+RIqWKY9evXq0+fPqpTv74+XrJE7h4eRkcqNTLS03UqJkZHjxzRwf37FRkRoaPR0Tp65IiOHTkms/mipJzrX139Vb16dasrUAEAAAAYjqclAkXph++/17jQUI0bN06vv/46v7gbrGPHjvr999/VoWNHDRs0SAuWLpWdHX8N3qiE+HhLYXU0OlrHoqOvKLCOWKatenp5KSAwULXr1lXLdu301Rf11axJLc2ZU1seFIoAAAAAChm/1QFF5FBEhEaGhOjRRx/VpEmTjI6DS2677TatXrVKrVu31kujRmn6u+8aHalEubrAOnTggA5FRCj68GElXlr/ys7eXpX9/RVQrZoCAgPVsl07BQQGKqBaNdWsU0cuLi45zrlxrYcqVLAVvRYAAACAokC5BRSBjPR0Pdm/vxrffbfmzp1rdBxcpVGjRlq4cKEeeughtWrXTj169TI6UrHJyszUyRMn8hx9FXXwoGX9KwdHR1Xy81NAtWq648479eCl6ZwB1arJv2pV2draGvxOAAAAAOA/lFtAEfjwgw905tQp/fLTT7K3tzc6DvIQHBysJ554QlNeeUXtO3fONdrIml25/tWVBdbBAwf0b1SUsrKyJP3/9MGAatXUqm1b9XvsMcvPVatVYxotAAAAAKtAuQUUslMxMZoVFqaXXnpJAQEBRsfBNbzxxhtatmyZZoeH6/nx4wt0bEJ8vObPmqXO3burQcOGRZTw2tfPb/2r40ePKjs7W1LOAiuoc2dVvbQWVt369eXh6VnsuQEAAACgsFFuAYXso1mz5O3jo1GjRhkdBddRoUIFjR8/XhMnTlTIiBFyc3e/7jFJiYn6aPZszX3vPaUkJ6tGrVpFVm5dq8A6Gh0tSbKzs1PlKlXyXP+qRu3acnV1LZJsAAAAAFBSUG4BhSgrM1PLFi/WC88/LycnJ6Pj4AY8+eSTeu2117Rq+XL1e/TRfPdLTk7Wp/PmaVZ4uNJSU5WVlSV7Bwcd+fffW7r+6VOndCgiIld5dTgyUslJSZIkewcH+VWunGeBVad+fTk6Ot5SBgAAAACwZpRbQCHavnWrzsfFqU+fPkZHwQ3y8vJSp06dtOG77/IstzLS07VsyRLNmDRJFxISdPHiRctr2RcvWkZQ5SczI0MxJ0/mOfrq0IEDSktLkyQ5OjoqIDBQderVy7X+VZWAANnY2BTq+wYAAACA0oJyCyhEO/74Q4HVq6tWrVpGR0EBBAUFafz48TKbzZZF1DMzMvTV4sV6+403FH/+fI5S67KLFy/qcGSk0tPTdTomRgcPHNChiIgcBdaJY8csx15rAfeAwMDifMsAAAAAUGpQbgGFKGL/ft1pwOLiuDUNGzZUQkKCTp86pfLly+vLRYv0ztSpijt3zrIwe3727dmjun5+kiRbW1v5+furWvXqqhYYqNb3369qgYGqVr26AqpXv+n1ry4kJMhsNisjI0OpKSmSpMQLF5Sdna2srCwlJydLkpITE5V1qUhLSUpS5qWnIkqSzGYlJCTkOG9GerrSUlNvKpMkubi6yu6Kp4GaTKZci9Q7OjjofFw5RUbaaePG/17z8vKSyWSSu7u77Ozs5OLiIkdHRzk6Opaqp1YCAAAAKB6UW0AhiouN1R3169/yeZYsWaJ+/fpJ+m+62uWpazdrxYoVevDBBy0/p6amsibYFSpWrChJWvzpp1ry2Wc6e+aMzGazzGbzdY/NSE/XnM8+U42aNeVdrpxSU1KUnJSk5ORkpSQnKzExUX/v2qUtmzZZtiUnJyszI0MXEhIshVVSUpKysrL+25aertTUVCVf2nYznJyc5HjVn7G7h0eO6Y22trY3tIh+fi4XbJdlZWVZ1gm7LCUlRZkZGTocKa1Zc/1zmkwmeXl5ydXVVa6urnJzc5OXl5dcXFzk6uoqDw8PeXh4yMvLSz4+PipXrpzly8fHRz4+PnJzc7vp91QUCvvzfDPeeustjR49WpLk7++v48ePF3sGAAAAoKiYzDfy2xtQBoWFSW/OMGvr3vgbPqZ3ly5q2by5wsPDCyVDUFCQfvvttxy/DCclJalRo0aqW7euVq9eXaDzBQcHa+XKlYaUW7eSu6h9/PHHGjx48E0fb+/goMyMjHxf9/D0lKurq1wufbm6ucne3l4eHh5ycHSUs7OzXFxdZe/gIA9PTzk4OMjZxUUuLi6yd3CQu7u7bGxtZW9nJ5dLo79c3dxkZ2eXo6C6vH9J81BnD93bzKyJExNlNpsVH//fZyohIUHZ2dlKSkpSZmamUlNTlZKSooSEBCVdKgiTk5MVHx+vlJQUJScn68KFC0pMTNT58+cVGxuruLi4XCWko6OjfHx85Ofnp8qVK+f48vPzk7+/vypXrmwpNYtLXp/nG1GYn5277rpL586do9wCAABAaXKCkVtAIbu8ZlNRMZvNys7OznO6nJubm+666y799ttvRZrhZlwrt9E6dux4zddNJtM1R3E9OmSImt97r1xcXeXh6Sk3d/f/SixX11saGVWa2NjYydvbW5Lk4+NTqOe+XHJd/ufl70+ePKmYmBhFRkZq06ZNOnnyZI6pmW5ubqpVq5Zq166tWrVqWb6vW7euKlSoUKgZb0VJ/uwAAAAAJQHlFmBl3N3dFRUVZXSMAivJuS8Xkq9Om6amzZvL08tL7u7uOn36tHbv3Kndf/2lP7dt08H9+5WZmSlbW1vZ2NgoMzNTNjY28qtcWR26djX4XZRdl6cl1q5d+7r7pqSk6MSJEzp58qQiIyN16NAhRUZGas2aNYqMjFTKpTXNqlSponvuuSfHV7ly5Yr6reSpJH92AAAAgJKAcgsALrnjzjvV4IoHAnh6e6tOvXrq/cgjkqSszExF7N+v3X/9pX927dKObdsUdfCgjkZHG5QYBeXi4qLatWurdu3aatu2ba7Xjx8/roiICO3YsUPbt2/Xhx9+qAkTJkiS6tevr86dO6tr16667777ZGtrW9zxAQAAAOTB5vq7AChqBw4cUHBwsDwvrc3UunXrPKcWrlixQiaTyfJ1ee2et956SyaTScnJydq8ebPldTu7vPvrU6dOqW/fvvLy8lK5cuXUvXv3PEeGnD17Vs8++6wCAwPl4OAgX19f9erVS3/99Ve+mSIiItSnTx+VK1fOsm3+/Pl55r762Ojo6BvKdeX9cnFxUdOmTbV69WoFBQVZzjVkyJCb+rO4Fjt7ezVo2FD9Hn1UU8LCtH7zZu0/flxPPftsoV8LxqhSpYrat2+vMWPGaNmyZYqOjtbp06e1Zs0adevWTRs2bFCHDh0UEBCg8ePH68yZM7nOcbOf5+L47Fxt4cKFOc5jMpl06tSpW7+RAAAAQDGi3AIMFhkZqRYtWmjHjh1atmyZTp8+rVmzZmnSpEm5fjkNDg6W2WxWz549c2x/4YUXZDab5erqqpYtW1qe9Jffk/ZCQ0MVGhqqEydO6KuvvtKmTZssT3O7LCYmRk2aNNGXX36pWbNmKS4uTj///LPi4uLUokULbdmyJc9MISEhGjZsmI4dO6atW7fK1tY239xXb78y19KlS/Xjjz/mynX1/Tpz5owWLFigmTNnavfu3XJ0dJTZbNb8+fML+CdxcxwcHVW5SpViuRaMUaFCBXXt2lUzZszQP//8o4iICA0ZMkQff/yxqlevrvDwcMuabLfyeS7qz05e+vXrp1GjRqlDhw6WxfkrVapUGLcNAAAAKDaUW4DBxo8fr/j4eM2cOVMdOnSQm5ub7rjjDi1YsEAxMTFFcs0hQ4aoRYsWcnV11f3336/u3btr+/btOnfunGWfcePG6ciRI3rnnXfUtWtXubm5qUGDBlqyZInMZrNGjBiR57nHjBmjdu3aycXFRc2aNVNWVpbKly9f4FxBQUHq1q1brlx53a8GDRpo0aJFSk5OvrUbA9yAOnXqaOLEifr33381btw4vfjiixo3bpykW/s8F/Vn52rx8fHq1q2bLl68qLVr11oW/AcAAACsDeUWYLB169ZJkjp16pRje+XKlVWnTp0iuWaTJk1y/Ozv7y9JOnnypGXbihUrZGNjo+7du+fYt1KlSmrQoIH+/PNPHT9+PNe5mzZtWmi5qlatmitXfvfL19dX9erVu+lrAwXl7OysCRMmaM6cOZoxY4bi4uJu6fNc1J+dK0VERKhZs2aysbFReHg464cBAADAqlFuAQZKT09XYmKinJyc5Obmluv1ChUqFMl1PT09c/xsY/PfXwXZ2dmWXAkJCcrOzpanp2euNXl27twpSTp06FCuc7u6uhZaLgcHh1y5rnW/GHkCI9SsWVPZ2dk6c+bMLX2ei/Kzc6Xz588rODhYVapU0dq1a7Vw4cKbvi4AAABQEvC0RMBAjo6Ocnd3V2JiopKSknL9QhwXF1eg85lMpkLL5eXlpaSkJKWmpua7MH1xu979ymtx7+JgNpsL7d7DumzatEkDBgxQp06dVK9evUL9PBcVOzs7bdy4UZ6enrr33nv15JNPqm7durlGfwEAAADWgpFbgMG6dOki6f+n21127tw5RUREFOhcLi4uysjIsPxct25dzZs376Zy9erVS1lZWdq8eXOu16ZPn66AgIB8F6wvSvndr1OnTungwYPFkiE5OVkb163TKy++qDaNG+vIv/8Wy3VRMmRkZGj16tUKDg5W27Ztdffdd2vJkiWSCvfzXFTc3d3l7+8vNzc3ffvtt3Jzc1NwcHCRrfEHAAAAFDXKLcBgU6ZMkY+Pj0JDQ7VhwwYlJSVp3759GjBgQJ5Tm66lcePGOnjwoI4dO6YtW7bo8OHDat269U3lmjp1qmrWrKknnnhCa9euVUJCguLi4jR37ly9/vrreuuttwwZ0ZXX/dqzZ48GDRpUZE95M5vN2rt7t2aHh6tP9+66s3p1Pdm/v75YsEBHo6Pl6eVVJNdFyREbG6tVq1ZpyJAhqlSpknr27Km4uDitWrVKK1askNelfwcK8/NcHAIDA7Vs2TKdPXtWvXr1Unp6utGRAAAAgAKj3AIMVrNmTW3ZskVNmjRR7969VaFCBT3++OMaMWKE7rjjDqWnp8tkMmnIkCFasWKFTCaTVq5cKem/Ba0HDBhgOVd4eLgaNmyo+vXrq2/fvpo5c6bq16+vrVu35jpuwoQJkv6byjh9+nRJUqNGjSwLyFeoUEHbtm1TcHCwhg8fblmw/ZtvvtHKlSvVp08fScrz3FdP0csv983kuvp+VaxYUSEhIRo3bpyqV69eaAtjx8XGas3KlRobGqp76tZVt3bt9M7Uqdq+dauysrJkNpt18eJFmUwmeVy13hGsW0pKinbt2qWPPvpITzzxhOrXry9fX1/17NlTu3fv1oQJExQdHa1ff/1V3bp1y3FsQT7PxfnZWbJkiUwmk/7++2+dOHFCJpNJ4eHh2rp1q9q1a6fMzExt3bpVTk5OOf5OAQAAAKyByWw2m40OAZREYWHSmzPM2ro3/oaP6d2li1q1aKGwsLAiTIb81KtXT6mpqTpy5EiBjjtx4oSqVKmiN999V7GxsVq3apV279ol6b/F9i9evJjvsS4uLtqXx1Mj8f8e6uyhVi1sFR5udJL/l5aWpqNHj+r48eM6dOiQIiIitG/fPkVEROjIkSMym81ycXFRkyZN1LJlS917771q0aKFfHx8jI4OAAAAIKcTJWOVaAC4QadOndJtt92m06dPy97e3rI9OjpaUVFRBR51cvHiRX3wwQeSpBeffTbP16/F2cVFp2Ji5OzsLI9LT5aEcZKTk3X27FmdPn1aZ8+e1blz53TmzBmdOHFCR48e1bFjx3Ts2LEcDx/w8PBQ3bp1Vb9+fbVt21b16tVT/fr1VatWrRLzMAUAAAAA+eN/tQOwOufPn1dISIgmTpyocuXKac+ePRoxYoQ8PDz08ssvF+hctra2euaZZzR16lS1bd9em3/9VTKbb3ix/MQLF9S8QQPLz46OjnJydpanl5ecnJzk5OwsDw8POTk7///3Li5ycnKSu4eHXFxc5OTsLDd3d7m6usrJyUmubm5yc3eXk5OTXFxdJUkOjo5ydnYu0HuzJllZWUpMTFRKSorS09OVkJCgjC/ms70AACAASURBVIwMy5MH4+PjlZCQYPnnld+fP39e586d07lz55SSkpLjvC4uLvL19ZW/v7+qVq2q++67T1WrVlW1atVUtWpVVa1aVb6+vga9awAAAACFgXILKET29vY5nlaIwlepUiVt3LhRH3zwgdq0aaOTJ0/K29tbQUFBWrRokWrUqFHgc17+Mxs1frzemTVLXy5apAVz5+rs6dPXnZZYp359vf7mm0pJSVHihQtKS01VamqqEuLjlZ6WprTUVF1ISFBqaqrSUlN1NDpaKSkpSktLU1JiopKTk5WWkqLk5OQbzntl0WVvb28pwHJ97+IiSbKzt5frpe1Xfl8YEuLzn7abmJio7IsXdfCArY5FJ+i336TMzEwlJSVJkqXIio+P1/VmyLu6usrT01NeXl7y9PS0fF+rVi15eXmpfPny8vX1tfyzYsWK8vX1tdwDAAAAAKUX5RZQiDy8vBQXF2d0jFKvffv2at++faGd7/KfmZeXl8r5+urp555TyIgR+nH9es2fNUtbN2+WnZ2dsjIzcx3rX6WKGjdpUig5khITlZaWppTk5P+KsrQ0paamSpJSU1IsJVxaSorSL3+fmmp5wl16WprS09L++z49XWmXjr3y+5TkZMWePVsoeSXJZGMjDw+PPF+r6Ocnezs7HdjvoKpVvRUUZJKNjY08Ly3A7+Tk9N90Tg8POTg4yMPDQ87OznJycpKnp6ccHBzk7u4ud3d3pgcCAAAAyBe/LQCFqEbNmvrtp5+MjoEC2r9/vxwcHeVftaplm42NjYI6d1ZQ586KOnRIn3/0kRZ/9pkuZmVZpiza2tnJy9u70HK4ubvLzd1dKmXT5CL2/7eg/LRpRicBAAAAUBrZGB0AKE0aNm6sfXv3KjY21ugoKIBff/1VtzdsmO/ooJq1a+u1adP0x969Gv3yy6rk5yeTyaTsixflcWkUEgAAAADAGJRbQCFq3a6dbG1t9e233xodBTcoMzNT365apfs6dLjuvl7e3goZMUKbd+/W3M8+U/NWrQp15BYAAAAAoOCYlggUIjd3d3Xq1k2z58zRoEGDjI6DG7BixQqdPXNGvfr2veFjbG1t1bFbN3Xs1k2ZPEAAAAAAAAzFyC2gkA155hnt2L5dX3/9tdFRcB0ZGRma8PLL6tqzZ471tgrC3sGhkFMBAAAAAAqCcgsoZHc2bqxe//ufQkeOVEpKitFxcA0zZ87U0aNHNfbVV42OAgAAAAC4SZRbQBEY88orij9/Xi+//LLRUZCPiIgITZ48WU89+6yqBAQYHQcAAAAAcJMot4AiUKFiRU1++22FhYXp448/NjoOrhIbG6vuPXqoVp06ejo01Og4AAAAAIBbwILyQBEJfvhhHY6M1FNPPaWqVauqww08jQ9FLyUlRQ899JDS0tK0ZPVqOTo6Gh0JAAAAAHALGLkFFKGRY8eqR69e6t69uxYsWGB0nDLv5MmTat2mjf7Zs0fzFy9WeV9foyMBAAAAAG4RI7eAImQymfT2rFmqXKWKBg8erH379mnSpElycnIyOlqZ8/vvv6tP375ycXXV8vXrVa16daMjAQAAAAAKASO3gCJmMpn0wksv6Z3ZszV79mzd1qCBVqxYYXSsMiMmJkaPPfaYWrVqpbr16+vrdesotgAAAACgFKHcAorJg3366Mft23XXPfeoV69euvfee/X5558rPj7e6Giljtls1o4dOzR8+HDVqVNHP/38s2Z/8ok+XrpUHp6eRscDAAAAABQipiUCxahipUoKmzNHAwcP1ocffKDBgwfLbDbrzrvuUoPbblO5cuXk4OBgdEyrFR8fryNHjmjnrl06c/q0qtesqdCxYzXgiSeYCgoAAAAApRTlFmCAxk2aaPYnnyghPl6//vij/t65U1GHDmnvgQPKzMgwOl6hyMzI0LFjxxQQECA7e/tiuaabh4cqVqqkIc88o1Zt2+q2O+4olusCAAAAAIxDuQUYyNPLSz169VKPXr2MjlLo0tPT1bZxY7Vo00Yvv/GG0XEAAAAAAKUUa24BKBKOjo4aOny4Fn78sc6cPm10HAAAAABAKUW5BaDI9H/iCXl5e2v+Bx8YHQUAAAAAUEpRbgEoMo6Ojnry0uit2LNnjY4DAAAAACiFKLcAFKmBgwfLzd1dHzJ6CwAAAABQBCi3ABQpR0dHDXnmGX02fz6jtwAAAAAAhY5yC0CRG/DEE3J2ddX82bONjgIAAAAAKGUotwAUORcXFz35zDP6dN48xZ07Z3QcAAAAAEApQrkFoFg8OmSInF1d9dGcOUZHAQAAAACUIpRbAIqFi4uLhjz9tD6ZO1dxsbFGxwEAAAAAlBKUWwCKzWNDh8rR2VkL5s41OgoAAAAAoJSg3AJQbFxcXDT4qae0YO5cxZ8/b3QcAAAAAEApQLkFoFg9HhIiBwcHRm8BAAAAAAoF5RaAYuXq6qpBISH6eM4cJcTHGx0HAAAAAGDlKLcAFLtBISGytbVl9BYAAAAA4JZRbgEodm7u7hoUEqKPZs/WhYQEo+MAAAAAAKwY5RYAQzzx1FOysbHRJ/PmGR0FAAAAAGDFKLcAGMLdw0ODQkI0f9YsRm8BAAAAAG4a5RYAwwx++mlJ0mfz5xucBAAAAABgrSi3ABjG3cNDjw8dqvmzZik5KcnoOAAAAAAAK0S5BcBQQ4YNU3Z2tj798EOjowAAAAAArBDlFgBDeXh6auDgwfrwgw8YvQUAAAAAKDDKLQCGGzJsmDIyMvTZRx8ZHQUAAAAAYGUotwAYztvHR48OGaJ5773H6C0AAAAAQIFQbgEoEYYOH66MjAwtXLDA6CgAAAAAACtCuQWgRPD28dHAJ57Q3HffVXJystFxAAAAAABWgnILQIkxdMQIpaeladEnnxgdBQAAAABgJSi3AJQYPuXKqf+gQZr77rtKTU01Og4AAAAAwApQbgEoUZ567jmlpqQwegsAAAAAcEMotwCUKD7lyqnfY49pzsyZjN4CAAAAAFwX5RaAEuep555TUmKiFn/6qdFRAAAAAAAlHOUWgBKnvK+v+j3+uGaHhystLc3oOAAAAACAEoxyC0CJ9PRzzynxwgUt+ewzo6MAAAAAAEowyi0AJZJvhQrq99hjmhUWxugtAAAAAEC+KLcAlFhPh4bqQkKCvvriC6OjAAAAAABKKMotACVWhYoV1XfgQM0KD1dGerrRcQAAAAAAJRDlFoAS7ZlRo3Q+NlZfLVpkdBQAAAAAQAlEuQWgRKtQsaIe7t9f77/zjjIzMoyOAwAAAAAoYSi3AJR4w0JDFXvunL5avNjoKAAAAACAEoZyC0CJ5+fvr4cfeUTvv/02o7cAAAAAADlQbgGwCsNHjdLZM2f09dKlRkcBAAAAAJQglFsArIKfv78e7tdP7731FqO3AAAAAAAWlFsArMbw55/XmdOntfyrr4yOAgAAAAAoISi3AFiNylWq6KG+ffX+228rKyvL6DgAAAAAgBKAcguAVRnxwguKOXlSK7780ugoAAAAAIASgHILgFXxr1pVDz78sN5j9BYAAAAAQJRbAKzQ8Oef14ljx7Ry2TKjowAAAAAADEa5BcDqBAQGKrhPH7331luM3gIAAACAMo5yC4BVGvH88zp+9KhWffON0VEAAAAAAAai3AJglapVr66evXtr5owZJW701rz331egj48CfXzUvEGD624HAAAAANw8yi0AVmvECy/o+JEjWrNihdFRchg6fLii4+JU//bbb2g7AAAAAODmUW4BsFqBNWqoR69eCps+XRcvXjQ6DgAAAADAAJRbAKzas6NH61h0tL5budLoKAAAAAAAA1BuAbBq1WvWVLfgYM18801lZ2cbHQcAAAAAUMwotwBYvWdHj9bhyEh99+23+e7z5IABlsXcA3181LtLF8trm3/5RYE+Ptq4bp1l2+vjx+fYPysrS1lZWVq9fLkGPPig7qlbV3X9/NSpZUt9PGfOLRVry7/8Mse1An18dPbMmZs+HwAAAACUJZRbAKxerTp11LVnT82cPj3fkunDhQs1acYMSdLMefO0bO1ay2vLv/pKkrTi0j8l6ZUpUzTv88/Vsm1bRcfFyc7OTr/88IOGDx6se9u00Q9//KEte/ao32OPafKECZr22ms3nf+Bhx7SkGHD1LpdO/19+LCi4+LkW6HCTZ8PAAAAAMoSyi0ApcJzL76oqEOHtG716nz36dGrl+wdHPTN0qWWbWlpadrw3XcKrFFDG9euVXJSkuW1r5cuVa++fXOco3mrVho2cqQ8vbzkU66cHh86VD1799bHc+cqKTGxwLkvJCRoUN++ys7O1idffSVPL68CnwMAAAAAyjLKLQClQu26ddWlRw+FT5uW7+gtL29v3dehg377+WfLtL8N332nu+6+W48OHqy0tDStW7VKkhR//ry2/vabOvfoYTm+fadOWpLH1Mf6t9+urMxMHTxwoECZD0dGqmdQkGxsbPTKlCmytbUt0PEAAAAAAMotAKXIc2PGKPLgQa1fsybffR7q21cXL17UymXLJEnfLF2qh/73Pz3Qu7dsbW0tUxO//fprte/USa6urpZjEy9c0DtTp6pTy5ZqWL26ZX2sKa+8IklKTUm54awJ8fF6sn9/+fn76+eNG7X8yy9v5i0DAAAAQJlHuQWg1KhTr546deumsGuM3rq/Y0d5eXvrm6VLFXfunHbt2KGO3bqpvK+vWt93n37ftElnTp/W14sXq9f//pfj2MH9+undGTP0v0cf1c/bt+vf2FhFx8XplTfekCSZC5DV1s5OX6xYoQ+/+EL1brtNY597Tn/v2nWzbx0AAAAAyizKLQClyshx43QoIkIbr1gw/kr2Dg7q/uCD2vfPP5oxebI6dO0qJycnSVKvS6O6wqZO1ZnTp3Vv69aW4y5evKgdf/wh3woVNCgkRD7ly8tkMkn6b92ugnJzc1MlPz+5urpq/qJFcnVz09D+/XXm9OmbeNcAAAAAUHZRbgEoVerUq6cOXbsq/M03ZTbnPZbq8iLxiz/7TA9dsWB8x27d5OrmpsWffabghx+Wjc3//xVpa2ur5q1a6eyZM5r73nuKi41VWlqatmzapIULFtxS5ioBAZr9ySeKjY1VyMCBykhPv6XzAQAAAEBZQrkFoNR5bvRo7d+zRxvXrcvz9cZNmqh6zZqqXKWKmrVsadnu5OSkLg88IEm5piRK0vsffaRHHn9cn8ybp6a33aZWd96pr5cuVc/evSVJAx58UD3uv1/z3n9fgT4+2r9nj07FxCjQx0dvvfGGVn3zTa7tH8+erV07dqhvjx7KyszUrh07VMfPT6EhIUVwZwAAAACg9DGZ8xvaAJRxYWHSmzPM2ro33ugouAlPDhigk8ePa/VPP1mmD8IYD3X2UKsWtgoPNzoJAAAAgFLoBCO3AJRKoS++qH3//KMf1683OgoAAAAAoAhRbgEolRo0bKj2nTopbNq0fNfeAgAAAABYP8otAKVW6Jgx2rt7t3754QejowAAAAAAigjlFoBS6/Y779R9HTro7SlTGL0FAAAAAKUU5RaAUm3k2LHa8/ff2vTTT0ZHAQAAAAAUAcotAKXaHXfdpbbt2yts2jSjowAAAAAAigDlFoBSL3TMGO3asUObfv7Z6CgAAAAAgEJGuQWg1Lvr7rvV5v77FTZ1qtFRAAAAAACFjHILQJkwcuxY7dy+XZt/+cXoKAAAAACAQkS5BaBMaHTPPWrdrp3eYfQWAAAAAJQqlFsAyoyR48bpz23btGXTJqOjAAAAAAAKCeUWgDKjcZMmatm2rd6eMsXoKAAAAACAQkK5BaBMGTVunHb88Yf+2LzZ6CgAAAAAgEJAuQWgTLm7aVO1aN1a4W++aXQUAAAAAEAhoNwCUOY8P368tmzapG2//250FAAAAADALaLcAlDm3NOsmZq1bKmZM2YYHQUAAAAAcIsotwCUSaEvvqjNv/yibVu2GB0FAAAAAHALKLcAlEktWrdW03vv1XuM3gIAAAAAq0a5BaDMem70aG36+Wdt37rV6CgAAAAAgJtEuQWgzGrZtq2atmih9956y+goAAAAAICbRLkFoEwb8cIL+vXHH7Xjjz+MjgIAAAAAuAmUWwDKtNb33acmzZvr/bffNjoKAAAAAOAmUG4BKPOGP/+8ft64UX/v3Gl0FAAAAABAAVFuASjz2rZvr3uaNdPMN980OgoAAAAAoIAotwBA0jOjRunH9ev1965dRkcBAAAAABQA5RYASLqvQwfd2bix3psxw+goAAAAAIACoNwCgEueHT1aG9etY/QWAAAAAFgRyi0AuKR9p066s1EjnpwIAAAAAFaEcgsArjD8hRe0ce1a7Wb0FgAAAABYBcotALhChy5ddMddd+mDsDCjowAAAAAAbgDlFgBcZfioUVq/Zo3279ljdBQAAAAAwHVQbgHAVTp07arb77xT7/LkRAAAAAAo8Si3AOAqJpNJz4wcqXWrV+vA3r1GxwEAAAAAXAPlFgDkoVP37qrXoAFPTgQAAACAEo5yCwDyYDKZNOKFF/Tdt9/qwL59RscBAAAAAOSDcgsA8tGlRw/VqV9fH7zzjtFRAAAAAAD5oNwCgHyYTCYNf/55rVmxQhH79xsdBwAAAACQB8otALiGrg88oDr16mlWWJjRUQAAAAAAeaDcAoBrsLGx0TOjRmn18uWKOnQox2sZ6enavnWrQckAAAAAABLlFgBcV7fgYNWqU8fy5MT09HR9+uGHatGwoV4fP97gdAAAAABQttkZHQAASjobGxsNGzlSo55+Wv5Vq2rxp58q/vx5Xbx4UVmZmUbHAwAAAIAyjXILAK4jIz1dSYmJsre316ywMGVnZ1teu5CQoNTUVDk7OxuYEAAAAADKLsotAMhHamqqFn/6qT545x2dj4vLUWpdZjabdfL4cdWsXduAhAAAAAAAyi0AyMOpmBj1uO8+nTt7Vmaz+Zr7Hj96lHILAAAAAAzCgvIAkIdKfn56adIkmUwmmUymfPezs7PT8aNHizEZAAAAAOBKlFsAkI/ghx/Wex99JBsbG9nY5P3XpY2NjU4cP17MyQAAAAAAl1FuAcA1dOvZU/MWLsy34MrKytKxI0cMSAYAAAAAkCi3AOC62nfqpPmLFsnW1lamqwqu7OxsRR8+bFAyAAAAAADlFgDcgHZBQfpo8WLZ29nlGsHFmlsAAAAAYBzKLQC4QW3uv1+ff/21HBwcchRc8efPKz093cBkAAAAAFB2UW4BQAE0a9lSn3/zjRwcHS0Fl9ls1kkWlQcAAAAAQ1BuAUABNWneXAu/+UaOTk6ytbWVxNREAAAAADAK5RYA3IR7mjXTl6tXy9nFRZJ0jHILAAAAAAxhZ3QAAChKycnJ+u2nn/THli06sHevzsfGKiU5udDO7+7urpTkZE1/7TXNnTmz0M5bHNw9PFShUiXddscdatmmjZq0aCE7O/6zAAAAAMC68FsMgFLp2JEj+uCdd/Tt118rLS1NdzVqpLsbN1bFihXl5uZWqNeKiYnRjh071KNHj0I9b1FLSEjQkSNHtH71ar3/9tuqULGi+g4cqKHDh8vdw8PoeAAAAABwQyi3AJQqKSkpmh0ernnvv6+AgABNnz5dffv2la+vb5FeNzExUe7u7kV6jaIUFRWlTz75RLPnzNHiTz/V6Jdf1sOPPJLjqZAAAAAAUBLxWwuAUmPv7t3q2KKFPvvwQ02dMkV79+zR8OHDi7zYkmTVxZYk1axZU5MmTVLkoUPq/8gjemnUKPXp1k3nzp41OhoAAAAAXBPlFoBSYcN33+nhrl1Vt25dHTx4UCNHjpS9vb3RsayOl5eXwsPDtWvXLsXHxSk4KEgH9u0zOhYAAAAA5ItyC4DV++qLLxTy6KMaOHCg1q1dqwoVKhgdyerdfvvt2rpli2rWqKHenTvrrz//NDoSAAAAAOSJcguAVduyaZPGjxqlsWPHas6cOTztrxCVK1dO69evV9u2bTV0wACdPH7c6EgAAAAAkAvlFgCr9W9UlJ5+/HH16tVLkydPNjpOqeTg4KDFixerYsWKGtyvn5KTk42OBAAAAAA5UG4BsFrjR45U9erVtWDBAplMJqPjlFru7u5avWqVTp86pXfffNPoOAAAAACQA+UWAKu0evly/fH775oze7acnZ2NjlPqBQQEaNLrr2vB3Lk6HBlpdBwAAAAAsKDcAmB1MtLTNfXVV/XYY4+padOmRscpM0JCQlS3Xj1NeeUVo6MAAAAAgAXlFgCr89233+r0qVOaNGmS0VHKFFtbW70xebJ++P57/RsVZXQcAAAAAJBEuQXACi3/8kt1795d/v7+Rkcpc7p27Sr/KlW04quvjI4CAAAAAJIotwBYmdTUVG357TcFBwcbHaVMsrW11QM9euinDRuMjgIAAAAAkii3AFiZA3v3KiM9Xa1atTI6SpnVsmVL7d+zR5kZGUZHAQAAAADKLQDWJfrwYTk4OKh69epGRymz6tevr8zMTB0/dszoKAAAAABAuQXAuiReuCBPLy/Z2PDXl1G8vb0lSRcuXDA4CQAAAABQbgGwMpmZmbK3tzc6RpFLSkpS7dq11b17d6Oj5HL5/jMtEQAAAEBJQLkFACWQ2WxWdna2srOzjY4CAAAAACWandEBAAC5ubu7KyoqyugYAAAAAFDiMXILAAAAAAAAVotyC0CptmLFCplMJstXRESE+vTpo3Llylm2hYaGWr5v1aqV5dh169ZZtpcvXz7fc0ZHR6tv377y8vJSuXLl1L179xyjrm51/7S0tJs6z2UHDhxQcHCwPD095eLioqZNm2r16tUKCgqynGvIkCFFcfsBAAAAoMhRbgEo1YKDg2U2m9WzZ09JUkhIiIYNG6Zjx45p69atsrW11YQJE2Q2m+Xq6prj2M6dO8tsNuvuu+++5jlDQ0MVGhqqEydOaOnSpfrxxx/Vr1+/Qtv/Zs8jSZGRkWrRooV27NihZcuW6cyZM1qwYIFmzpyp3bt3y9HRUWazWfPnz7+V2wwAAAAAhqHcAlCmjBkzRu3atZOLi4uaNWumrKysHKOybsaQIUPUokULubq6KigoSN26ddP27dt17ty5Qtn/Vq47fvx4xcfHa+bMmerQoYPc3NzUoEEDLVq0SMnJybf0vgEAAACgJKDcAlCmNG3atNDP2aRJkxw/V61aVZJ08uTJQtn/Vq67bt06SVKnTp1y7Ovr66t69eoV6HoAAAAAUBJRbgEoU66eelgYPD09c/zs4OAgScrOzi6U/W/2uunp6UpMTJSTk5Pc3NxyHe/t7V2g6wEAAABASUS5BQCX2NjYKCMjI9f2+Ph4A9LcOkdHR7m7uystLU1JSUm5Xj9z5owBqQAAAACgcFFuAcAlfn5+OnHiRI5tp06d0tGjRw1KdOu6dOki6f+nJ1526tQpHTx40IhIAAAAAFCoKLcA4JKOHTvq5MmTev/995WUlKSoqCg999xzqlChgtHRbtqUKVPk4+Oj0NBQbdiwQUlJSdqzZ48GDRqkSpUqGR0PAAAAAG4Z5RaAUm3r1q0ymUxauXKlJMnZ2VkmkynPfSdPnqwhQ4ZoypQpqlChgh5//HGNHj1alSpVUmxsrEwmk8aOHZvnOSdMmCBJMplMmj59uiSpUaNG6t69e4H3X7FiRa79BwwYUODzSFLNmjW1ZcsWNWnSRL1791bFihUVEhKicePGqXr16rK1tS3Euw0AAAAAxc/O6AAAUJSaN28us9l8Q/t6enrqww8/zLV9x44dubbld86Stl2S6tSpo+XLl+faHhMTo/Lly+d7HAAAAABYA0ZuAUApdurUKfn4+CgzMzPH9ujoaEVFRen+++83KBkAAAAAFA7KLQBWJe8JhbiW8+fPKyQkRMeOHVNKSoq2bdumvn37ysPDQy+//PJNnze/6Z0AAAAAUJwotwBYFScXF6WkpBgdw2pUqlRJGzduVHx8vNq0aSNvb2898MADql27trZt26YaNWoU+JxJSUmSJFdX18KOCwAAAAAFxppbAKxK+fLldSEhQSkpKXJxcTE6jlVo37692rdvX2jnO336tCTJh/W6AAAAAJQAjNwCYFXq1K+v7Oxs7d692+goZdZff/0lL29vVahY0egoAAAAAEC5BcC6VKteXX6VK2vDhg1GRymz1q9fr2YtWxodAwAAAAAkUW4BsDImk0ntO3fWosWLZTabjY5T5pw9e1YbN25Uxy5djI4CAAAAAJIotwBYoX6PPqoD+/fr+++/NzpKmTN79mw5OTmpa3Cw0VEAAAAAQBLlFgAr1KBhQ3Xq1k0jR41SZmam0XHKjBMnTmjGjBkKefZZOTs7Gx0HAAAAACRRbgGwUi9NmqR///1Xs2bNMjpKmTF69GiV8/XV4GHDjI4CAAAAABaUWwCsUkBgoIYOH66XXnpJO3fuNDpOqff5559ryZIlevmNN+To6Gh0HAAAAACwoNwCYLVCx4xRs5Yt1a17dx0/ftzoOKXW5s2b9eSTT+qp555TUOfORscBAAAAgBwotwBYLVtbW4XPnSt3Dw917dZNJ0+eNDpSqbNt2zb1DA5Wuw4dNHrCBKPjAAAAAEAulFsArJqHp6cWLF2q1PR0NW3WTLt27TI6Uqnx1VdfqV27dmp4110KnztXNjb8JwMAAABAycNvKgCsXpWAAH2zbp1q1K6t1q1b6/3331dWVpbRsazWhQsX9Pzzz6tv377636OPav7ixTwdEQAAAECJRbkFoFS4PILr8ZAQPf/CC7qrUSNt2LDB6FhWJSsrSwsWLFCdunX1yaefasZ77+nVqVNla2trdDQAAAAAyBflFoBSw87OTqMnTND6zZvlV6WKOnbsqDsaNtS0adP0559/KiMjw+iIJc6FCxf0yy+/aMyYMaoWGKihQ4eqc48e+mn7dvV+5BGj4wEAAADAddkZHQAACltgjRqav2iR/t61S0s+/VTvhIVp3Lhxsre3l5e3t9zc3IyOWCLEx8cr/vx5mc1mGxRTegAACbtJREFUVa9ZUw/27av/DRyoqtWqGR0NAAAAAG4Y5RaAUuvORo10Z6NGeiM7W1GHDili3z7FnjunlJQUo6OVCB4eHqpQqZJuu/12+VetanQcAAAAALgplFsASj0bGxvVrltXtevWNToKAAAAAKCQseYWAAAAAAAArBblFgAAAAAAAKwW5RYAAAAAAACsFuUWAAAAAAAArBblFgAAAAAAAKwW5RYAAAAAAACsFuUWAAAAAAAArJad0QGAkiwzU9q9y9boGIBVS0k2OgEAAACA0oxyC7iG2HMmPdDew+gYgNXrGGR0AgAAAACllclsNpuNDgGURAkJUmys0SmA0sHTUypXzugUAAAAAEqhE5RbAAAAAAAAsFYnWFAeAAAAAAAAVotyCwAAAAAAAFaLcgsAAAAAAABWi3ILAAAAAAAAVotyCwAAAAAAAFaLcgsAAAAAAABWi3ILAAAAAAAAVotyCwAAAPi/du4sJKr+j+P4xzYdR5ssSyukJDAKTKzMFgXJQmxBg4yoiCJKMAyRJFuoi2m5KNBJWgm6CSuwBbGNiLqwLOiihRal5cL/04IamlNamr//RTT/5m/5NJM5z+F5v2Au5pzv75zvd66GD+d3AACAZRFuAQAAAAAAwLIItwAAAAAAAGBZhFsAAAAAAACwLMItAAAAAAAAWBbhFgAAAAAAACyLcAsAAAAAAACWRbgFAAD6hNvtVlBQkNenpqbmb9cVFRV5rdm5c2cfdOvt1KlTnvuHhIT8bb2VZwUAALCaIGOMCXQTAADg3+PevXtKTEyUJGVmZurixYs/rW1qatLYsWPldru1fPlynThxoq/a/KE5c+aourpa7e3tv1Rv1VndbrcSExM1fvx4VVVVBawPAACAX/AXT24BAIA+Z7PZNGbMGF26dEl37979aV1JSYliYmL6sLPeF4hZw8LClJKS4vd6Y4y6urrU1dXVK/0AAAD8SYRbAACgz/Xr10/FxcWS9NOtd83NzTp06JA2bdrUl631OivOGh4erufPn/f4pBkAAMA/BeEWAAAIiNWrV2v06NGqrKzUgwcPup3fv3+/5s2bp3HjxgWgu971b5oVAACgrxFuAQCAgAgODlZRUZGMMdq1a5fXObfbrbKyMm3ZsqXHazQ1NamwsFDjxo3ToEGDFBERoczMTF2/fv23ap8+fars7Gw5HA7Z7Xalpqaquro6YLN2dnbq9OnTmjt3rqKjo2Wz2RQfHy+Xy+W1dXDfvn0KCgrShw8fdPPmTc+L6QcMGCBJOn/+vNcL62tra7VkyRINGzbMc+zYsWNeNd/eL5aSkuJ1fMWKFZK+vofs++PNzc1+/04AAAD+INwCAAABs27dOkVFRamiokJPnjzxHD9w4IBmz56tCRMm/HTtmzdvlJSUpPLycrlcLjU2NurOnTsKDQ1Venq6jh075lfts2fPNGPGDN29e1cVFRV6+/atDh48KKfTqefPnwdk1suXL2vp0qWaPXu2njx5ovr6eq1bt06FhYVeWxk3btwoY4zsdrtmzZolY4yMMers7JQkZWdnyxijrKwsSVJubq7y8vJUX1+v27dvq3///t1qvqmurta9e/dkt9uVkJCgI0eOSJIuXLig5ORknTx5UsYYDRkyxO/fCAAAwB+EWwAAIGBsNpsKCwvV1dWl3bt3S5I+fvyokpISbd26tce1mzdv1suXL1VaWqoFCxZo8ODBiouLU3l5uUaOHKkNGzbo7du3Ptdu2bJFzc3Ncrlcmjt3rsLCwhQfH6/jx4/r9evXAZlVktLS0rR582ZFREQoMjJS+fn5WrZsmVwul96/f+9XT5s2bVJaWppCQ0OVnJyszs5ORUZG/rQ+ISFBx48f1/3797Vy5UoZY5Sbm6v09HQtXbrUrx4AAAB+F+EWAAAIqLy8PA0bNkwnT57Us2fPdOTIEU2fPl2TJk3qcd25c+ckSfPnz/c6HhwcrPT0dLW1tenKlSs+116+fFmSlJGR4VU7atQoxcXF+TnlV/7OumDBgh9un0xISFBHR4cePXrkVz/Tpk3zeU1OTo62bt2qs2fPKiUlRU1NTXI6nX7dHwAAoDcQbgEAgIAKCwtTQUGBvnz5oh07dmjfvn3atm1bj2s+ffqklpYWhYSEKDw8vNv5qKgoSV+3I/pa29raqpCQEIWFhXWrHTFihD8jevgzqyS1tLRo+/btio+PV0REhOf9VkVFRZK+PgHmD7vd7tc6p9Op5ORk3bp1Szk5OerXj7+UAAAgcPgnAgAAAi4/P18Oh0Pl5eVKSEjQ1KlTe6wPDg6Ww+FQe3u7Wltbu53/tsUwOjra59rw8HC1t7fL7XZ3q3337p0/43nxdVZJWrhwoZxOp9auXau6ujp1dXXJGKOSkhJJkjHGqz4oKOi3++zJjRs31NLSovj4eOXl5en+/ft/9H4AAAA9IdwCAAAB53A4VFhYKIfD8UtPMknSokWLJH19ofn3Pn36pGvXrslms3m2FvpSm5mZKel/2xO/aWxsVG1trY+TdefrrF++fNHNmzcVHR2tDRs2aPjw4Z7wqq2t7YdrQkND9fnzZ8/38ePH6+jRo7/duyS9fPlSa9as0ZkzZ1RZWSmbzaasrCw1NDT0yvUBAAB8RbgFAAD+EbZv367m5mbNnDnzl+r37Nmj2NhYFRQUqKqqSq2traqrq9OyZcv0+vVruVwuz5ZDX2p3796toUOHqqCgQFevXpXb7dbjx4+1YsWKH25V/NOz9u/fX2lpaXrz5o327t2rxsZGtbW16fr16zp8+PAP10yePFl1dXWqr69XTU2NXrx4odTU1N/u2+12Kzs7W6WlpZo4caLGjh2riooKvXr1SosXL1ZHR8dv3wMAAMBnBgAAoI/Y7XYjyfPJyMjosf772m+fsrIyz/nGxkZTUFBgYmNjzcCBA43D4TAZGRnm2rVr3a7lS21tba3Jzs42gwcPNjabzSQlJZmqqiqTnp7u6WPNmjV9NmtDQ4PJzc01MTExZuDAgSYqKsqsWrXKFBcXe2qnTJniudbTp09NamqqsdvtJiYmxhw4cMAYY0xNTc0P7/O9c+fOdTu/fPlys379eq9jDx8+NA0NDd1qnU5nj3MCAAD0sv8EGfN/L2kAAAAAAAAArOEvtiUCAAAAAADAsgi3AAAAAAAAYFmEWwAAAAAAALAswi0AAAAAAABYFuEWAAAAAAAALItwCwAAAAAAAJZFuAUAAAAAAADLItwCAAAAAACAZRFuAQAAAAAAwLIItwAAAAAAAGBZhFsAAAAAAACwLMItAAAAAAAAWBbhFgAAAAAAACyLcAsAAAAAAACWRbgFAAAAAAAAy/ovP74hhLJ63BAAAAAASUVORK5CYII=\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.relax()\n",
"model.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"model.show_graph(show_roi=True)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# multimodel test\n",
"model1 = Matter()\n",
"model2 = Matter()\n",
"machine = CustomStateMachine(model=[model1, model2], states=states, transitions=transitions, **extra_args)\n",
"model1.drink()\n",
"model1.drink()\n",
"model2.walk()\n",
"model1.show_graph()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.1"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
transitions-0.8.10+3/pytest.ini 0000644 0002322 0002322 00000000175 14155650047 016724 0 ustar debalance debalance [pytest]
filterwarnings =
error
ignore:.*With-statements.*:DeprecationWarning
addopts = -x -rf
junit_family = xunit2
transitions-0.8.10+3/requirements_test.txt 0000644 0002322 0002322 00000000114 14155650047 021207 0 ustar debalance debalance pytest
pytest-cov
pytest-runner
pytest-xdist
mock
dill
graphviz
pycodestyle
transitions-0.8.10+3/.pylintrc 0000644 0002322 0002322 00000034642 14155650047 016546 0 ustar debalance debalance [MASTER]
# A comma-separated list of package or module names from where C extensions may
# be loaded. Extensions are loading into the active Python interpreter and may
# run arbitrary code
extension-pkg-whitelist=
# Add files or directories to the blacklist. They should be base names, not
# paths.
ignore=CVS
# Add files or directories matching the regex patterns to the blacklist. The
# regex matches against base names, not paths.
ignore-patterns=
# Python code to execute, usually for sys.path manipulation such as
# pygtk.require().
#init-hook=
# Use multiple processes to speed up Pylint.
jobs=1
# List of plugins (as comma separated values of python modules names) to load,
# usually to register additional checkers.
load-plugins=
# Pickle collected data for later comparisons.
persistent=yes
# Specify a configuration file.
#rcfile=
# Allow loading of arbitrary C extensions. Extensions are imported into the
# active Python interpreter and may run arbitrary code.
unsafe-load-any-extension=no
[MESSAGES CONTROL]
# Only show warnings with the listed confidence levels. Leave empty to show
# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
confidence=
# Disable the message, report, category or checker with the given id(s). You
# can either give multiple identifiers separated by comma (,) or put this
# option multiple times (only on the command line, not in the configuration
# file where it should appear only once).You can also use "--disable=all" to
# disable everything first and then reenable specific checks. For example, if
# you want to run only the similarities checker, you can use "--disable=all
# --enable=similarities". If you want to run only the classes checker, but have
# no Warning level messages displayed, use"--disable=all --enable=classes
# --disable=W"
disable=print-statement,parameter-unpacking,unpacking-in-except,old-raise-syntax,backtick,long-suffix,old-ne-operator,old-octal-literal,import-star-module-level,raw-checker-failed,bad-inline-option,locally-disabled,locally-enabled,file-ignored,suppressed-message,useless-suppression,deprecated-pragma,apply-builtin,basestring-builtin,buffer-builtin,cmp-builtin,coerce-builtin,execfile-builtin,file-builtin,long-builtin,raw_input-builtin,reduce-builtin,standarderror-builtin,unicode-builtin,xrange-builtin,coerce-method,delslice-method,getslice-method,setslice-method,no-absolute-import,old-division,dict-iter-method,dict-view-method,next-method-called,metaclass-assignment,indexing-exception,raising-string,reload-builtin,oct-method,hex-method,nonzero-method,cmp-method,input-builtin,round-builtin,intern-builtin,unichr-builtin,map-builtin-not-iterating,zip-builtin-not-iterating,range-builtin-not-iterating,filter-builtin-not-iterating,using-cmp-argument,eq-without-hash,div-method,idiv-method,rdiv-method,exception-message-attribute,invalid-str-codec,sys-max-int,bad-python3-import,deprecated-string-function,deprecated-str-translate-call
# Enable the message, report, category or checker with the given id(s). You can
# either give multiple identifier separated by comma (,) or put this option
# multiple time (only on the command line, not in the configuration file where
# it should appear only once). See also the "--disable" option for examples.
enable=
[REPORTS]
# Python expression which should return a note less than 10 (10 is the highest
# note). You have access to the variables errors warning, statement which
# respectively contain the number of errors / warnings messages and the total
# number of statements analyzed. This is used by the global evaluation report
# (RP0004).
evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
# Template used to display messages. This is a python new-style format string
# used to format the message information. See doc for all details
#msg-template=
# Set the output format. Available formats are text, parseable, colorized, json
# and msvs (visual studio).You can also give a reporter class, eg
# mypackage.mymodule.MyReporterClass.
output-format=text
# Tells whether to display a full report or only the messages
reports=no
# Activate the evaluation score.
score=yes
[REFACTORING]
# Maximum number of nested blocks for function / method body
max-nested-blocks=5
[BASIC]
# Naming hint for argument names
argument-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Regular expression matching correct argument names
argument-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Naming hint for attribute names
attr-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Regular expression matching correct attribute names
attr-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Bad variable names which should always be refused, separated by a comma
bad-names=foo,bar,baz,toto,tutu,tata
# Naming hint for class attribute names
class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
# Regular expression matching correct class attribute names
class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$
# Naming hint for class names
class-name-hint=[A-Z_][a-zA-Z0-9]+$
# Regular expression matching correct class names
class-rgx=[A-Z_][a-zA-Z0-9]+$
# Naming hint for constant names
const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
# Regular expression matching correct constant names
const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
# Minimum line length for functions/classes that require docstrings, shorter
# ones are exempt.
docstring-min-length=-1
# Naming hint for function names
function-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Regular expression matching correct function names
function-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Good variable names which should always be accepted, separated by a comma
good-names=i,j,k,ex,Run,_
# Include a hint for the correct naming format with invalid-name
include-naming-hint=no
# Naming hint for inline iteration names
inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
# Regular expression matching correct inline iteration names
inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
# Naming hint for method names
method-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Regular expression matching correct method names
method-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Naming hint for module names
module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
# Regular expression matching correct module names
module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
# Colon-delimited sets of names that determine each other's naming style when
# the name regexes allow several styles.
name-group=
# Regular expression which should only match function or class names that do
# not require a docstring.
no-docstring-rgx=^_
# List of decorators that produce properties, such as abc.abstractproperty. Add
# to this list to register other decorators that produce valid properties.
property-classes=abc.abstractproperty
# Naming hint for variable names
variable-name-hint=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
# Regular expression matching correct variable names
variable-rgx=(([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$
[FORMAT]
# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
expected-line-ending-format=
# Regexp for a line that is allowed to be longer than the limit.
ignore-long-lines=^\s*(# )??$
# Number of spaces of indent required inside a hanging or continued line.
indent-after-paren=4
# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
# tab).
indent-string=' '
# Maximum number of characters on a single line.
max-line-length=120
# Maximum number of lines in a module
max-module-lines=1000
# List of optional constructs for which whitespace checking is disabled. `dict-
# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}.
# `trailing-comma` allows a space between comma and closing bracket: (a, ).
# `empty-line` allows space-only lines.
no-space-check=trailing-comma,dict-separator
# Allow the body of a class to be on the same line as the declaration if body
# contains single statement.
single-line-class-stmt=no
# Allow the body of an if to be on the same line as the test if there is no
# else.
single-line-if-stmt=no
[LOGGING]
# Logging modules to check that the string format arguments are in logging
# function parameter format
logging-modules=logging
[MISCELLANEOUS]
# List of note tags to take in consideration, separated by a comma.
notes=FIXME,XXX,TODO
[SIMILARITIES]
# Ignore comments when computing similarities.
ignore-comments=yes
# Ignore docstrings when computing similarities.
ignore-docstrings=yes
# Ignore imports when computing similarities.
ignore-imports=no
# Minimum lines number of a similarity.
min-similarity-lines=4
[SPELLING]
# Spelling dictionary name. Available dictionaries: none. To make it working
# install python-enchant package.
spelling-dict=
# List of comma separated words that should not be checked.
spelling-ignore-words=
# A path to a file that contains private dictionary; one word per line.
spelling-private-dict-file=
# Tells whether to store unknown words to indicated private dictionary in
# --spelling-private-dict-file option instead of raising a message.
spelling-store-unknown-words=no
[TYPECHECK]
# List of decorators that produce context managers, such as
# contextlib.contextmanager. Add to this list to register other decorators that
# produce valid context managers.
contextmanager-decorators=contextlib.contextmanager
# List of members which are set dynamically and missed by pylint inference
# system, and so shouldn't trigger E1101 when accessed. Python regular
# expressions are accepted.
generated-members=
# Tells whether missing members accessed in mixin class should be ignored. A
# mixin class is detected if its name ends with "mixin" (case insensitive).
ignore-mixin-members=yes
# This flag controls whether pylint should warn about no-member and similar
# checks whenever an opaque object is returned when inferring. The inference
# can return multiple potential results while evaluating a Python object, but
# some branches might not be evaluated, which results in partial inference. In
# that case, it might be useful to still emit no-member and other checks for
# the rest of the inferred objects.
ignore-on-opaque-inference=yes
# List of class names for which member attributes should not be checked (useful
# for classes with dynamically set attributes). This supports the use of
# qualified names.
ignored-classes=optparse.Values,thread._local,_thread._local
# List of module names for which member attributes should not be checked
# (useful for modules/projects where namespaces are manipulated during runtime
# and thus existing member attributes cannot be deduced by static analysis. It
# supports qualified module names, as well as Unix pattern matching.
ignored-modules=
# Show a hint with possible names when a member name was not found. The aspect
# of finding the hint is based on edit distance.
missing-member-hint=yes
# The minimum edit distance a name should have in order to be considered a
# similar match for a missing member name.
missing-member-hint-distance=1
# The total number of similar names that should be taken in consideration when
# showing a hint for a missing member.
missing-member-max-choices=1
[VARIABLES]
# List of additional names supposed to be defined in builtins. Remember that
# you should avoid to define new builtins when possible.
additional-builtins=
# Tells whether unused global variables should be treated as a violation.
allow-global-unused-variables=yes
# List of strings which can identify a callback function by name. A callback
# name must start or end with one of those strings.
callbacks=cb_,_cb
# A regular expression matching the name of dummy variables (i.e. expectedly
# not used).
dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
# Argument names that match this expression will be ignored. Default to name
# with leading underscore
ignored-argument-names=_.*|^ignored_|^unused_
# Tells whether we should check for unused import in __init__ files.
init-import=no
# List of qualified module names which can have objects that can redefine
# builtins.
redefining-builtins-modules=six.moves,future.builtins,builtins
[CLASSES]
# List of method names used to declare (i.e. assign) instance attributes.
defining-attr-methods=__init__,__new__,setUp
# List of member names, which should be excluded from the protected access
# warning.
exclude-protected=_asdict,_fields,_replace,_source,_make
# List of valid names for the first argument in a class method.
valid-classmethod-first-arg=cls
# List of valid names for the first argument in a metaclass class method.
valid-metaclass-classmethod-first-arg=mcs
[DESIGN]
# Maximum number of arguments for function / method
max-args=5
# Maximum number of attributes for a class (see R0902).
max-attributes=7
# Maximum number of boolean expressions in a if statement
max-bool-expr=5
# Maximum number of branch for function / method body
max-branches=12
# Maximum number of locals for function / method body
max-locals=15
# Maximum number of parents for a class (see R0901).
max-parents=7
# Maximum number of public methods for a class (see R0904).
max-public-methods=20
# Maximum number of return / yield for function / method body
max-returns=6
# Maximum number of statements in function / method body
max-statements=50
# Minimum number of public methods for a class (see R0903).
min-public-methods=2
[IMPORTS]
# Allow wildcard imports from modules that define __all__.
allow-wildcard-with-all=no
# Analyse import fallback blocks. This can be used to support both Python 2 and
# 3 compatible code, which means that the block might have code that exists
# only in one or another interpreter, leading to false positives when analysed.
analyse-fallback-blocks=no
# Deprecated modules which should not be used, separated by a comma
deprecated-modules=regsub,TERMIOS,Bastion,rexec
# Create a graph of external dependencies in the given file (report RP0402 must
# not be disabled)
ext-import-graph=
# Create a graph of every (i.e. internal and external) dependencies in the
# given file (report RP0402 must not be disabled)
import-graph=
# Create a graph of internal dependencies in the given file (report RP0402 must
# not be disabled)
int-import-graph=
# Force import order to recognize a module as part of the standard
# compatibility libraries.
known-standard-library=
# Force import order to recognize a module as part of a third party library.
known-third-party=enchant
[EXCEPTIONS]
# Exceptions that will emit a warning when being caught. Defaults to
# "Exception"
overgeneral-exceptions=Exception
transitions-0.8.10+3/tests/ 0000755 0002322 0002322 00000000000 14155650047 016032 5 ustar debalance debalance transitions-0.8.10+3/tests/utils.py 0000644 0002322 0002322 00000005125 14155650047 017547 0 ustar debalance debalance from transitions import Machine
class Stuff(object):
is_false = False
is_True = True
def __init__(self, states=None, machine_cls=Machine, extra_kwargs={}):
self.state = None
self.message = None
states = ['A', 'B', 'C', 'D', 'E', 'F'] if states is None else states
args = [self]
kwargs = {
'states': states,
'initial': 'A',
'name': 'Test Machine',
}
kwargs.update(extra_kwargs)
if machine_cls is not None:
self.machine = machine_cls(*args, **kwargs)
self.level = 1
self.transitions = 0
self.machine_cls = machine_cls
@staticmethod
def this_passes():
return True
@staticmethod
def this_fails():
return False
@staticmethod
def this_raises(exception, *args, **kwargs):
raise exception
@staticmethod
def this_fails_by_default(boolean=False):
return boolean
@staticmethod
def extract_boolean(event_data):
return event_data.kwargs['boolean']
def goodbye(self):
self.message = "So long, suckers!"
def hello_world(self):
self.message = "Hello World!"
def greet(self):
self.message = "Hi"
def meet(self):
self.message = "Nice to meet you"
def hello_F(self):
if not hasattr(self, 'message'):
self.message = ''
self.message += "Hello F!"
def increase_level(self):
self.level += 1
self.transitions += 1
def decrease_level(self):
self.level -= 1
self.transitions += 1
def set_message(self, message="Hello World!"):
self.message = message
def extract_message(self, event_data):
self.message = event_data.kwargs['message']
def on_enter_E(self, msg=None):
self.message = "I am E!" if msg is None else msg
def on_exit_E(self):
self.exit_message = "E go home..."
def on_enter_F(self):
self.message = "I am F!"
@property
def property_that_fails(self):
return self.is_false
class InheritedStuff(Machine):
def __init__(self, states, initial='A'):
self.state = None
Machine.__init__(self, states=states, initial=initial)
@staticmethod
def this_passes():
return True
class DummyModel(object):
pass
class SomeContext(object):
def __init__(self, event_list):
self._event_list = event_list
def __enter__(self):
self._event_list.append((self, "enter"))
def __exit__(self, type, value, traceback):
self._event_list.append((self, "exit"))
transitions-0.8.10+3/tests/test_pygraphviz.py 0000644 0002322 0002322 00000007545 14155650047 021661 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from .utils import Stuff
from .test_graphviz import TestDiagrams, TestDiagramsNested
from transitions.extensions.states import add_state_features, Timeout, Tags
from unittest import skipIf
try:
# Just to skip tests if graphviz not installed
import pygraphviz as pgv # @UnresolvedImport
except ImportError: # pragma: no cover
pgv = None
@skipIf(pgv is None, 'Graph diagram requires pygraphviz')
class PygraphvizTest(TestDiagrams):
use_pygraphviz = True
def setUp(self):
super(PygraphvizTest, self).setUp()
def test_if_multiple_edges_are_supported(self):
transitions = [
['event_0', 'a', 'b'],
['event_1', 'a', 'b'],
['event_2', 'a', 'b'],
['event_3', 'a', 'b'],
]
m = self.machine_cls(
states=['a', 'b'],
transitions=transitions,
initial='a',
auto_transitions=False,
use_pygraphviz=self.use_pygraphviz
)
graph = m.get_graph()
self.assertIsNotNone(graph)
self.assertTrue("digraph" in str(graph))
triggers = [transition[0] for transition in transitions]
for trigger in triggers:
self.assertTrue(trigger in str(graph))
def test_multi_model_state(self):
m1 = Stuff(machine_cls=None)
m2 = Stuff(machine_cls=None)
m = self.machine_cls(model=[m1, m2], states=self.states, transitions=self.transitions, initial='A',
use_pygraphviz=self.use_pygraphviz)
m1.walk()
self.assertEqual(m1.get_graph().get_node(m1.state).attr['color'],
m1.get_graph().style_attributes['node']['active']['color'])
self.assertEqual(m2.get_graph().get_node(m1.state).attr['color'],
m2.get_graph().style_attributes['node']['default']['color'])
# backwards compatibility test
self.assertEqual(id(m.get_graph()), id(m1.get_graph()))
def test_to_method_filtering(self):
m = self.machine_cls(states=['A', 'B', 'C'], initial='A')
m.add_transition('to_state_A', 'B', 'A')
m.add_transition('to_end', '*', 'C')
e = m.get_graph().get_edge('B', 'A')
self.assertEqual(e.attr['label'], 'to_state_A')
e = m.get_graph().get_edge('A', 'C')
self.assertEqual(e.attr['label'], 'to_end')
with self.assertRaises(KeyError):
m.get_graph().get_edge('A', 'B')
m2 = self.machine_cls(states=['A', 'B'], initial='A', show_auto_transitions=True)
self.assertEqual(len(m2.get_graph().get_edge('B', 'A')), 2)
self.assertEqual(m2.get_graph().get_edge('A', 'B').attr['label'], 'to_B')
def test_roi(self):
m = self.machine_cls(states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A')
m.add_transition('to_state_A', 'B', 'A')
m.add_transition('to_state_C', 'B', 'C')
m.add_transition('to_state_F', 'B', 'F')
g1 = m.get_graph(show_roi=True)
self.assertEqual(len(g1.edges()), 0)
self.assertEqual(len(g1.nodes()), 1)
m.to_B()
g2 = m.get_graph(show_roi=True)
self.assertEqual(len(g2.edges()), 4)
self.assertEqual(len(g2.nodes()), 4)
def test_state_tags(self):
@add_state_features(Tags, Timeout)
class CustomMachine(self.machine_cls):
pass
self.states[0] = {'name': 'A', 'tags': ['new', 'polling'], 'timeout': 5, 'on_enter': 'say_hello',
'on_exit': 'say_goodbye', 'on_timeout': 'do_something'}
m = CustomMachine(states=self.states, transitions=self.transitions, initial='A', show_state_attributes=True)
g = m.get_graph(show_roi=True)
@skipIf(pgv is None, 'NestedGraph diagram requires pygraphviz')
class TestPygraphvizNested(TestDiagramsNested, PygraphvizTest):
use_pygraphviz = True
transitions-0.8.10+3/tests/test_states.py 0000644 0002322 0002322 00000014021 14155650047 020744 0 ustar debalance debalance from transitions import Machine
from transitions.extensions.states import *
from transitions.extensions import MachineFactory
from time import sleep
from unittest import TestCase
from .test_graphviz import TestDiagramsLockedNested
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
class TestTransitions(TestCase):
def test_tags(self):
@add_state_features(Tags)
class CustomMachine(Machine):
pass
states = [{"name": "A", "tags": ["initial", "success", "error_state"]}]
m = CustomMachine(states=states, initial='A')
s = m.get_state(m.state)
self.assertTrue(s.is_initial)
self.assertTrue(s.is_success)
self.assertTrue(s.is_error_state)
self.assertFalse(s.is_not_available)
def test_error(self):
@add_state_features(Error)
class CustomMachine(Machine):
pass
states = ['A', 'B', 'F',
{'name': 'S1', 'tags': ['accepted']},
{'name': 'S2', 'accepted': True}]
transitions = [['to_B', ['S1', 'S2'], 'B'], ['go', 'A', 'B'], ['fail', 'B', 'F'],
['success1', 'B', 'S2'], ['success2', 'B', 'S2']]
m = CustomMachine(states=states, transitions=transitions, auto_transitions=False, initial='A')
m.go()
m.success1()
self.assertTrue(m.get_state(m.state).is_accepted)
m.to_B()
m.success2()
self.assertTrue(m.get_state(m.state).is_accepted)
m.to_B()
with self.assertRaises(MachineError):
m.fail()
def test_error_callback(self):
@add_state_features(Error)
class CustomMachine(Machine):
pass
mock_callback = MagicMock()
states = ['A', {"name": "B", "on_enter": mock_callback}, 'C']
transitions = [
["to_B", "A", "B"],
["to_C", "B", "C"],
]
m = CustomMachine(states=states, transitions=transitions, auto_transitions=False, initial='A')
m.to_B()
self.assertEqual(m.state, "B")
self.assertTrue(mock_callback.called)
def test_timeout(self):
mock = MagicMock()
@add_state_features(Timeout)
class CustomMachine(Machine):
def timeout(self):
mock()
states = ['A',
{'name': 'B', 'timeout': 0.3, 'on_timeout': 'timeout'},
{'name': 'C', 'timeout': 0.3, 'on_timeout': mock}]
m = CustomMachine(states=states)
m.to_B()
m.to_A()
sleep(0.4)
self.assertFalse(mock.called)
m.to_B()
sleep(0.4)
self.assertTrue(mock.called)
m.to_C()
sleep(0.4)
self.assertEqual(mock.call_count, 2)
with self.assertRaises(AttributeError):
m.add_state({'name': 'D', 'timeout': 0.3})
def test_timeout_callbacks(self):
timeout = MagicMock()
notification = MagicMock()
counter = MagicMock()
@add_state_features(Timeout)
class CustomMachine(Machine):
pass
class Model(object):
def on_timeout_B(self):
counter()
def timeout(self):
timeout()
def notification(self):
notification()
def another_notification(self):
notification()
states = ['A', {'name': 'B', 'timeout': 0.05, 'on_timeout': 'timeout'}]
model = Model()
machine = CustomMachine(model=model, states=states, initial='A')
model.to_B()
sleep(0.1)
self.assertTrue(timeout.called)
self.assertTrue(counter.called)
machine.get_state('B').add_callback('timeout', 'notification')
machine.on_timeout_B('another_notification')
model.to_B()
sleep(0.1)
self.assertEqual(timeout.call_count, 2)
self.assertEqual(counter.call_count, 2)
self.assertTrue(notification.called)
machine.get_state('B').on_timeout = []
model.to_B()
sleep(0.1)
self.assertEqual(timeout.call_count, 2)
self.assertEqual(notification.call_count, 2)
def test_timeout_transitioning(self):
timeout_mock = MagicMock()
@add_state_features(Timeout)
class CustomMachine(Machine):
pass
states = ['A', {'name': 'B', 'timeout': 0.05, 'on_timeout': ['to_A', timeout_mock]}]
machine = CustomMachine(states=states, initial='A')
machine.to_B()
sleep(0.1)
self.assertTrue(machine.is_A())
self.assertTrue(timeout_mock.called)
def test_volatile(self):
class TemporalState(object):
def __init__(self):
self.value = 5
def increase(self):
self.value += 1
@add_state_features(Volatile)
class CustomMachine(Machine):
pass
states = ['A', {'name': 'B', 'volatile': TemporalState}]
m = CustomMachine(states=states, initial='A')
m.to_B()
self.assertEqual(m.scope.value, 5)
# should call method of TemporalState
m.scope.increase()
self.assertEqual(m.scope.value, 6)
# re-entering state should reset default volatile object
m.to_A()
self.assertFalse(hasattr(m.scope, 'value'))
m.scope.foo = 'bar'
m.to_B()
# custom attribute of A should be gone
self.assertFalse(hasattr(m.scope, 'foo'))
# value should be reset
self.assertEqual(m.scope.value, 5)
class TestStatesDiagramsLockedNested(TestDiagramsLockedNested):
def setUp(self):
machine_cls = MachineFactory.get_predefined(locked=True, nested=True, graph=True)
@add_state_features(Error, Timeout, Volatile)
class CustomMachine(machine_cls):
pass
super(TestStatesDiagramsLockedNested, self).setUp()
self.machine_cls = CustomMachine
def test_nested_notebook(self):
# test will create a custom state machine already. This will cause errors when inherited.
self.assertTrue(True)
transitions-0.8.10+3/tests/test_factory.py 0000644 0002322 0002322 00000003650 14155650047 021116 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from unittest import TestCase
from transitions.extensions import MachineFactory
class TestFactory(TestCase):
def setUp(self):
self.factory = MachineFactory()
def test_mixins(self):
machine_cls = self.factory.get_predefined()
self.assertFalse(hasattr(machine_cls, 'set_edge_state'))
graph_cls = self.factory.get_predefined(graph=True)
self.assertTrue(hasattr(graph_cls, '_get_graph'))
nested_cls = self.factory.get_predefined(nested=True)
self.assertFalse(hasattr(nested_cls, '_get_graph'))
self.assertTrue(hasattr(nested_cls, 'get_nested_triggers'))
locked_cls = self.factory.get_predefined(locked=True)
self.assertFalse(hasattr(locked_cls, '_get_graph'))
self.assertFalse(hasattr(locked_cls, 'get_nested_triggers'))
self.assertTrue('__getattribute__' in locked_cls.__dict__)
locked_nested_cls = self.factory.get_predefined(nested=True, locked=True)
self.assertFalse(hasattr(locked_nested_cls, '_get_graph'))
self.assertTrue(hasattr(locked_nested_cls, 'get_nested_triggers'))
self.assertEqual(locked_nested_cls.__getattribute__, locked_cls.__getattribute__)
self.assertNotEqual(machine_cls.__getattribute__, locked_cls.__getattribute__)
graph_locked_cls = self.factory.get_predefined(graph=True, locked=True)
self.assertTrue(hasattr(graph_locked_cls, '_get_graph'))
self.assertEqual(graph_locked_cls.__getattribute__, locked_cls.__getattribute__)
graph_nested_cls = self.factory.get_predefined(graph=True, nested=True)
self.assertNotEqual(nested_cls._create_transition, graph_nested_cls._create_transition)
locked_nested_graph_cls = self.factory.get_predefined(nested=True, locked=True, graph=True)
self.assertNotEqual(locked_nested_graph_cls._create_event, graph_cls._create_event)
transitions-0.8.10+3/tests/test_nesting_legacy.py 0000644 0002322 0002322 00000017203 14155650047 022441 0 ustar debalance debalance from .test_nesting import TestNestedTransitions, TestSeparatorsBase, Stuff, default_separator, test_states
from .test_reuse import TestReuse as TestReuse, TestReuseSeparatorBase
from .test_reuse import test_states as reuse_states
from .test_enum import TestNestedStateEnums
from transitions.extensions.nesting_legacy import HierarchicalMachine, NestedState
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
class TestNestedLegacySeparatorDefault(TestSeparatorsBase):
def setUp(self):
class CustomLegacyState(NestedState):
separator = self.separator
class CustomLegacyMachine(HierarchicalMachine):
state_cls = CustomLegacyState
self.states = test_states
self.state_cls = CustomLegacyState
self.machine_cls = CustomLegacyMachine
self.stuff = Stuff(self.states, self.machine_cls)
self.state_cls = self.machine_cls.state_cls
def test_ordered_with_graph(self):
pass
def test_example_two(self):
pass # not supported by legacy machine
class TestNestedLegacySeparatorDot(TestNestedLegacySeparatorDefault):
separator = '.'
class TestNestedLegacySeparatorSlash(TestNestedLegacySeparatorDefault):
separator = '/'
class TestNestedLegacy(TestNestedTransitions):
def setUp(self):
super(TestNestedLegacy, self).setUp()
self.machine_cls = HierarchicalMachine
self.stuff = Stuff(self.states, self.machine_cls)
self.state_cls = self.machine_cls.state_cls
def test_add_custom_state(self):
s = self.stuff
s.machine.add_states([{'name': 'E', 'children': ['1', '2']}])
s.machine.add_state('3', parent='E')
s.machine.add_transition('go', '*', 'E%s1' % self.state_cls.separator)
s.machine.add_transition('walk', '*', 'E%s3' % self.state_cls.separator)
s.machine.add_transition('run', 'E', 'C{0}3{0}a'.format(self.state_cls.separator))
s.go()
self.assertEqual('E{0}1'.format(self.state_cls.separator), s.state)
s.walk()
self.assertEqual('E{0}3'.format(self.state_cls.separator), s.state)
s.run()
self.assertEqual('C{0}3{0}a'.format(self.state_cls.separator), s.state)
def test_init_machine_with_nested_states(self):
State = self.state_cls
a = State('A')
b = State('B')
b_1 = State('1', parent=b)
b_2 = State('2', parent=b)
m = self.stuff.machine_cls(states=[a, b])
self.assertEqual(b_1.name, 'B{0}1'.format(State.separator))
m.to("B{0}1".format(State.separator))
def test_transitioning(self):
State = self.state_cls
s = self.stuff
s.machine.add_transition('advance', 'A', 'B')
s.machine.add_transition('advance', 'B', 'C')
s.machine.add_transition('advance', 'C', 'D')
s.machine.add_transition('reset', '*', 'A')
self.assertEqual(len(s.machine.events['reset'].transitions['C%s1' % State.separator]), 1)
s.advance()
self.assertEqual(s.state, 'B')
self.assertFalse(s.is_A())
self.assertTrue(s.is_B())
s.advance()
self.assertEqual(s.state, 'C')
def test_nested_definitions(self):
pass # not supported by legacy machine
def test_add_nested_state(self):
pass # not supported by legacy machine
def test_child_condition_persistence(self):
pass # not supported by legacy machine
def test_get_nested_transitions(self):
pass # not supported by legacy machine
def test_correct_subclassing(self):
pass # not supported by legacy machine
def test_queued_callbacks(self):
pass # not supported by legacy machine
def test_nested_transitions(self):
pass # not supported by legacy machine
class TestReuseLegacySeparatorDefault(TestReuseSeparatorBase):
def setUp(self):
class CustomLegacyState(NestedState):
separator = self.separator
class CustomLegacyMachine(HierarchicalMachine):
state_cls = CustomLegacyState
self.states = reuse_states
self.state_cls = CustomLegacyState
self.machine_cls = CustomLegacyMachine
self.stuff = Stuff(self.states, self.machine_cls)
self.state_cls = self.machine_cls.state_cls
class TestReuseLegacySeparatorDefault(TestReuseLegacySeparatorDefault):
separator = '.'
class TestReuseLegacy(TestReuse):
def setUp(self):
super(TestReuseLegacy, self).setUp()
self.machine_cls = HierarchicalMachine
self.stuff = Stuff(self.states, self.machine_cls)
self.state_cls = self.machine_cls.state_cls
def test_reuse_self_reference(self):
separator = self.state_cls.separator
class Nested(self.machine_cls):
def __init__(self, parent):
self.parent = parent
self.mock = MagicMock()
states = ['1', '2']
transitions = [{'trigger': 'finish', 'source': '*', 'dest': '2', 'after': self.print_msg}]
super(Nested, self).__init__(states=states, transitions=transitions, initial='1')
def print_msg(self):
self.mock()
self.parent.print_top()
class Top(self.machine_cls):
def print_msg(self):
self.mock()
def __init__(self):
self.nested = Nested(self)
self.mock = MagicMock()
states = ['A', {'name': 'B', 'children': self.nested}]
transitions = [dict(trigger='print_top', source='*', dest='=', after=self.print_msg),
dict(trigger='to_nested', source='*', dest='B{0}1'.format(separator))]
super(Top, self).__init__(states=states, transitions=transitions, initial='A')
top_machine = Top()
self.assertEqual(top_machine, top_machine.nested.parent)
top_machine.to_nested()
top_machine.finish()
self.assertTrue(top_machine.mock.called)
self.assertTrue(top_machine.nested.mock.called)
self.assertIsNot(top_machine.nested.get_state('2').on_enter,
top_machine.get_state('B{0}2'.format(separator)).on_enter)
def test_reuse_machine_config(self):
pass # not supported
class TestLegacyNestedEnum(TestNestedStateEnums):
def setUp(self):
super(TestLegacyNestedEnum, self).setUp()
self.machine_cls = HierarchicalMachine
self.machine_cls.state_cls.separator = default_separator
def test_nested_enums(self):
# Nested enums are currently not support since model.state does not contain any information about parents
# and nesting
states = ['A', 'B',
{'name': 'C', 'children': self.States, 'initial': self.States.GREEN}]
with self.assertRaises(AttributeError):
# NestedState will raise an error when parent is not None and state name is an enum
# Initializing this would actually work but `m.to_A()` would raise an error in get_state(m.state)
# as Machine is not aware of the location of States.GREEN
m = self.machine_cls(states=states, initial='C')
def test_add_enum_transition(self):
pass # not supported by legacy machine
def test_add_nested_enums_as_nested_state(self):
pass # not supported by legacy machine
def test_enum_initial(self):
pass # not supported by legacy machine
def test_separator_naming_error(self):
pass # not supported by legacy machine
def test_get_nested_transitions(self):
pass # not supported by legacy machine
def test_multiple_deeper(self):
pass # not supported by legacy machine
transitions-0.8.10+3/tests/__init__.py 0000644 0002322 0002322 00000000000 14155650047 020131 0 ustar debalance debalance transitions-0.8.10+3/tests/test_async.py 0000644 0002322 0002322 00000045043 14155650047 020566 0 ustar debalance debalance from transitions.extensions import MachineFactory
try:
import asyncio
except (ImportError, SyntaxError):
asyncio = None
from unittest.mock import MagicMock
from unittest import skipIf
from functools import partial
import weakref
from .test_core import TestTransitions, MachineError
from .utils import DummyModel
from .test_graphviz import pgv as gv
from .test_pygraphviz import pgv
@skipIf(asyncio is None, "AsyncMachine requires asyncio and contextvars suppport")
class TestAsync(TestTransitions):
@staticmethod
async def await_false():
await asyncio.sleep(0.1)
return False
@staticmethod
async def await_true():
await asyncio.sleep(0.1)
return True
@staticmethod
async def cancel_soon():
await asyncio.sleep(1)
raise TimeoutError("Callback was not cancelled!")
@staticmethod
def raise_value_error():
raise ValueError("ValueError raised.")
@staticmethod
def synced_true():
return True
@staticmethod
async def call_delayed(func, time):
await asyncio.sleep(time)
await func()
def setUp(self):
super(TestAsync, self).setUp()
self.machine_cls = MachineFactory.get_predefined(asyncio=True)
self.machine = self.machine_cls(states=['A', 'B', 'C'], transitions=[['go', 'A', 'B']], initial='A')
def test_new_state_in_enter_callback(self):
machine = self.machine_cls(states=['A', 'B'], initial='A')
async def on_enter_B():
state = self.machine_cls.state_cls(name='C')
machine.add_state(state)
await machine.to_C()
machine.on_enter_B(on_enter_B)
asyncio.run(machine.to_B())
def test_dynamic_model_state_attribute(self):
class Model:
def __init__(self):
self.status = None
self.state = 'some_value'
m = self.machine_cls(Model(), states=['A', 'B'], initial='A', model_attribute='status')
self.assertEqual(m.model.status, 'A')
self.assertEqual(m.model.state, 'some_value')
m.add_transition('move', 'A', 'B')
asyncio.run(m.model.move())
self.assertEqual(m.model.status, 'B')
self.assertEqual(m.model.state, 'some_value')
def test_async_machine_cb(self):
mock = MagicMock()
async def async_process():
await asyncio.sleep(0.1)
mock()
m = self.machine
m.after_state_change = async_process
asyncio.run(m.go())
self.assertEqual(m.state, 'B')
self.assertTrue(mock.called)
def test_async_condition(self):
m = self.machine
m.add_transition('proceed', 'A', 'C', conditions=self.await_true, unless=self.await_false)
asyncio.run(m.proceed())
self.assertEqual(m.state, 'C')
def test_async_enter_exit(self):
enter_mock = MagicMock()
exit_mock = MagicMock()
async def async_enter():
await asyncio.sleep(0.1)
enter_mock()
async def async_exit():
await asyncio.sleep(0.1)
exit_mock()
m = self.machine
m.on_exit_A(async_exit)
m.on_enter_B(async_enter)
asyncio.run(m.go())
self.assertTrue(exit_mock.called)
self.assertTrue(enter_mock.called)
def test_sync_conditions(self):
mock = MagicMock()
def sync_process():
mock()
m = self.machine
m.add_transition('proceed', 'A', 'C', conditions=self.synced_true, after=sync_process)
asyncio.run(m.proceed())
self.assertEqual(m.state, 'C')
self.assertTrue(mock.called)
def test_multiple_models(self):
m1 = self.machine_cls(states=['A', 'B', 'C'], initial='A', name="m1")
m2 = self.machine_cls(states=['A'], initial='A', name='m2')
m1.add_transition(trigger='go', source='A', dest='B', before=self.cancel_soon)
m1.add_transition(trigger='fix', source='A', dest='C', after=self.cancel_soon)
m1.add_transition(trigger='check', source='C', dest='B', conditions=self.await_false)
m1.add_transition(trigger='reset', source='C', dest='A')
m2.add_transition(trigger='go', source='A', dest=None, conditions=m1.is_C, after=m1.reset)
async def run():
_ = asyncio.gather(m1.go(), # should block before B
self.call_delayed(m1.fix, 0.05), # should cancel task and go to C
self.call_delayed(m1.check, 0.07), # should exit before m1.fix
self.call_delayed(m2.go, 0.1)) # should cancel m1.fix
assert m1.is_A()
asyncio.run(run())
def test_async_callback_arguments(self):
async def process(should_fail=True):
if should_fail is not False:
raise ValueError("should_fail has been set")
self.machine.on_enter_B(process)
with self.assertRaises(ValueError):
asyncio.run(self.machine.go())
asyncio.run(self.machine.to_A())
asyncio.run(self.machine.go(should_fail=False))
def test_async_callback_event_data(self):
state_a = self.machine_cls.state_cls('A')
state_b = self.machine_cls.state_cls('B')
def sync_condition(event_data):
return event_data.state == state_a
async def async_conditions(event_data):
return event_data.state == state_a
async def async_callback(event_data):
self.assertEqual(event_data.state, state_b)
def sync_callback(event_data):
self.assertEqual(event_data.state, state_b)
m = self.machine_cls(states=[state_a, state_b], initial='A', send_event=True)
m.add_transition('go', 'A', 'B', conditions=[sync_condition, async_conditions],
after=[sync_callback, async_callback])
m.add_transition('go', 'B', 'A', conditions=sync_condition)
asyncio.run(m.go())
self.assertTrue(m.is_B())
asyncio.run(m.go())
self.assertTrue(m.is_B())
def test_async_invalid_triggers(self):
asyncio.run(self.machine.to_B())
with self.assertRaises(MachineError):
asyncio.run(self.machine.go())
self.machine.ignore_invalid_triggers = True
asyncio.run(self.machine.go())
self.assertTrue(self.machine.is_B())
def test_async_dispatch(self):
model1 = DummyModel()
model2 = DummyModel()
model3 = DummyModel()
machine = self.machine_cls(model=None, states=['A', 'B', 'C'], transitions=[['go', 'A', 'B'],
['go', 'B', 'C'],
['go', 'C', 'A']], initial='A')
machine.add_model(model1)
machine.add_model(model2, initial='B')
machine.add_model(model3, initial='C')
asyncio.run(machine.dispatch('go'))
self.assertTrue(model1.is_B())
self.assertEqual('C', model2.state)
self.assertEqual(machine.initial, model3.state)
def test_queued(self):
states = ['A', 'B', 'C', 'D']
# Define with list of dictionaries
async def change_state(machine):
self.assertEqual(machine.state, 'A')
if machine.has_queue:
await machine.run(machine=machine)
self.assertEqual(machine.state, 'A')
else:
with self.assertRaises(MachineError):
await machine.run(machine=machine)
async def raise_machine_error(event_data):
self.assertTrue(event_data.machine.has_queue)
await event_data.model.to_A()
event_data.machine._queued = False
await event_data.model.to_C()
async def raise_exception(event_data):
await event_data.model.to_C()
raise ValueError("Clears queue")
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B', 'before': change_state},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = self.machine_cls(states=states, transitions=transitions, initial='A')
asyncio.run(m.walk(machine=m))
self.assertEqual('B', m.state)
m = self.machine_cls(states=states, transitions=transitions, initial='A', queued=True)
asyncio.run(m.walk(machine=m))
self.assertEqual('C', m.state)
m = self.machine_cls(states=states, initial='A', queued=True, send_event=True,
before_state_change=raise_machine_error)
with self.assertRaises(MachineError):
asyncio.run(m.to_C())
m = self.machine_cls(states=states, initial='A', queued=True, send_event=True)
m.add_transition('go', 'A', 'B', after='go')
m.add_transition('go', 'B', 'C', before=raise_exception)
with self.assertRaises(ValueError):
asyncio.run(m.go())
self.assertEqual('B', m.state)
def test_model_queue(self):
mock = MagicMock()
def check_mock():
self.assertTrue(mock.called)
m1 = DummyModel()
m2 = DummyModel()
async def run():
transitions = [{'trigger': 'mock', 'source': ['A', 'B'], 'dest': 'B', 'after': mock},
{'trigger': 'delayed', 'source': 'A', 'dest': 'B', 'before': partial(asyncio.sleep, 0.1)},
{'trigger': 'check', 'source': 'B', 'dest': 'A', 'after': check_mock},
{'trigger': 'error', 'source': 'B', 'dest': 'C', 'before': self.raise_value_error}]
m = self.machine_cls(model=[m1, m2], states=['A', 'B', 'C'], transitions=transitions, initial='A',
queued='model')
# call m1.delayed and m2.mock should be called immediately
# m1.check should be delayed until after m1.delayed
await asyncio.gather(m1.delayed(), self.call_delayed(m1.check, 0.02), self.call_delayed(m2.mock, 0.04))
self.assertTrue(m1.is_A())
self.assertTrue(m2.is_B())
mock.reset_mock()
with self.assertRaises(ValueError):
# m1.error raises an error which should cancel m1.to_A but not m2.mock and m2.check
await asyncio.gather(m1.to_A(), m2.to_A(),
self.call_delayed(m1.delayed, 0.01), self.call_delayed(m2.delayed, 0.01),
self.call_delayed(m1.error, 0.02), self.call_delayed(m1.to_A, 0.03),
self.call_delayed(m2.mock, 0.03), self.call_delayed(m2.check, 0.04))
await asyncio.sleep(0.05) # give m2 events time to finish
self.assertTrue(m1.is_B())
self.assertTrue(m2.is_A())
asyncio.run(run())
def test_queued_remove(self):
def remove_model(event_data):
event_data.machine.remove_model(event_data.model)
def check_queue(expect, event_data):
self.assertEqual(expect, len(event_data.machine._transition_queue_dict[id(event_data.model)]))
transitions = [
{'trigger': 'go', 'source': 'A', 'dest': 'B', 'after': partial(asyncio.sleep, 0.1)},
{'trigger': 'go', 'source': 'B', 'dest': 'C'},
{'trigger': 'remove', 'source': 'B', 'dest': None, 'prepare': ['to_A', 'to_C'],
'before': partial(check_queue, 4), 'after': remove_model},
{'trigger': 'remove_queue', 'source': 'B', 'dest': None, 'prepare': ['to_A', 'to_C'],
'before': partial(check_queue, 3), 'after': remove_model}
]
async def run():
m1 = DummyModel()
m2 = DummyModel()
m = self.machine_cls(model=[m1, m2], states=['A', 'B', 'C'], transitions=transitions,
initial='A', queued=True, send_event=True)
await asyncio.gather(m1.go(), m2.go(),
self.call_delayed(m1.remove, 0.02), self.call_delayed(m2.go, 0.04))
_ = repr(m._transition_queue_dict) # check whether _DictionaryMock returns a valid representation
self.assertTrue(m1.is_B())
self.assertTrue(m2.is_C())
m.remove_model(m2)
self.assertNotIn(id(m1), m._transition_queue_dict)
self.assertNotIn(id(m2), m._transition_queue_dict)
m1 = DummyModel()
m2 = DummyModel()
m = self.machine_cls(model=[m1, m2], states=['A', 'B', 'C'], transitions=transitions,
initial='A', queued='model', send_event=True)
await asyncio.gather(m1.go(), m2.go(),
self.call_delayed(m1.remove_queue, 0.02), self.call_delayed(m2.go, 0.04))
self.assertTrue(m1.is_B())
self.assertTrue(m2.is_C())
m.remove_model(m2)
asyncio.run(run())
def test_async_timeout(self):
from transitions.extensions.states import add_state_features
from transitions.extensions.asyncio import AsyncTimeout
timeout_called = MagicMock()
@add_state_features(AsyncTimeout)
class TimeoutMachine(self.machine_cls):
pass
states = ['A', {'name': 'B', 'timeout': 0.2, 'on_timeout': ['to_C', timeout_called]}, 'C']
m = TimeoutMachine(states=states, initial='A')
with self.assertRaises(AttributeError):
m.add_state('Fail', timeout=1)
async def run():
await m.to_B()
await asyncio.sleep(0.1)
self.assertTrue(m.is_B()) # timeout shouldn't be triggered
await m.to_A() # cancel timeout
self.assertTrue(m.is_A())
await m.to_B()
await asyncio.sleep(0.3)
self.assertTrue(m.is_C()) # now timeout should have been processed
self.assertTrue(timeout_called.called)
asyncio.run(run())
def test_callback_order(self):
finished = []
class Model:
async def before(self):
await asyncio.sleep(0.1)
finished.append(2)
async def after(self):
await asyncio.sleep(0.1)
finished.append(3)
async def after_state_change():
finished.append(4)
async def before_state_change():
finished.append(1)
model = Model()
m = self.machine_cls(
model=model,
states=['start', 'end'],
after_state_change=after_state_change,
before_state_change=before_state_change,
initial='start',
)
m.add_transition('transit', 'start', 'end', after='after', before='before')
asyncio.run(model.transit())
assert finished == [1, 2, 3, 4]
def test_task_cleanup(self):
models = [DummyModel() for i in range(100)]
m = self.machine_cls(model=models, states=['A', 'B'], initial='A')
self.assertEqual(0, len(m.async_tasks)) # check whether other tests were already leaking tasks
async def run():
for model in m.models:
await model.to_B()
asyncio.run(run())
self.assertEqual(0, len(m.async_tasks))
def test_on_exception_callback(self):
mock = MagicMock()
def on_exception(event_data):
self.assertIsInstance(event_data.error, ValueError)
mock()
m = self.machine_cls(states=['A', 'B'], initial='A', send_event=True,
after_state_change=partial(self.stuff.this_raises, ValueError))
async def run():
with self.assertRaises(ValueError):
await m.to_B()
m.on_exception.append(on_exception)
await m.to_B()
self.assertTrue(mock.called)
asyncio.run(run())
def test_weakproxy_model(self):
d = DummyModel()
pr = weakref.proxy(d)
self.machine_cls(pr, states=['A', 'B'], transitions=[['go', 'A', 'B']], initial='A')
asyncio.run(pr.go())
self.assertTrue(pr.is_B())
@skipIf(asyncio is None or (pgv is None and gv is None), "AsyncGraphMachine requires asyncio and (py)gaphviz")
class AsyncGraphMachine(TestAsync):
def setUp(self):
super(TestAsync, self).setUp()
self.machine_cls = MachineFactory.get_predefined(graph=True, asyncio=True)
self.machine = self.machine_cls(states=['A', 'B', 'C'], transitions=[['go', 'A', 'B']], initial='A')
class TestHierarchicalAsync(TestAsync):
def setUp(self):
super(TestAsync, self).setUp()
self.machine_cls = MachineFactory.get_predefined(nested=True, asyncio=True)
self.machine = self.machine_cls(states=['A', 'B', 'C'], transitions=[['go', 'A', 'B']], initial='A')
def test_nested_async(self):
mock = MagicMock()
async def sleep_mock():
await asyncio.sleep(0.1)
mock()
states = ['A', 'B', {'name': 'C', 'children': ['1', {'name': '2', 'children': ['a', 'b'], 'initial': 'a'},
'3'], 'initial': '2'}]
transitions = [{'trigger': 'go', 'source': 'A', 'dest': 'C',
'after': [sleep_mock] * 100}]
machine = self.machine_cls(states=states, transitions=transitions, initial='A')
asyncio.run(machine.go())
self.assertEqual('C{0}2{0}a'.format(machine.state_cls.separator), machine.state)
self.assertEqual(100, mock.call_count)
def test_parallel_async(self):
states = ['A', 'B', {'name': 'P',
'parallel': [
{'name': '1', 'children': ['a'], 'initial': 'a'},
{'name': '2', 'children': ['b', 'c'], 'initial': 'b'},
{'name': '3', 'children': ['x', 'y', 'z'], 'initial': 'y'}]}]
machine = self.machine_cls(states=states, initial='A')
asyncio.run(machine.to_P())
self.assertEqual(['P{0}1{0}a'.format(machine.state_cls.separator),
'P{0}2{0}b'.format(machine.state_cls.separator),
'P{0}3{0}y'.format(machine.state_cls.separator)], machine.state)
asyncio.run(machine.to_B())
self.assertTrue(machine.is_B())
@skipIf(asyncio is None or (pgv is None and gv is None), "AsyncGraphMachine requires asyncio and (py)gaphviz")
class AsyncHierarchicalGraphMachine(TestHierarchicalAsync):
def setUp(self):
super(TestHierarchicalAsync, self).setUp()
self.machine_cls = MachineFactory.get_predefined(graph=True, asyncio=True, nested=True)
self.machine = self.machine_cls(states=['A', 'B', 'C'], transitions=[['go', 'A', 'B']], initial='A')
transitions-0.8.10+3/tests/test_codestyle.py 0000644 0002322 0002322 00000001306 14155650047 021436 0 ustar debalance debalance import unittest
import pycodestyle
from os.path import exists
class TestCodeFormat(unittest.TestCase):
def test_conformance(self):
"""Test that we conform to PEP-8."""
style = pycodestyle.StyleGuide(quiet=False, ignore=['E501', 'W605'])
if exists('transitions'): # when run from root directory (e.g. tox)
style.input_dir('transitions')
style.input_dir('tests')
else: # when run from test directory (e.g. pycharm)
style.input_dir('../transitions')
style.input_dir('.')
result = style.check_files()
self.assertEqual(result.total_errors, 0,
"Found code style errors (and warnings).")
transitions-0.8.10+3/tests/test_core.py 0000644 0002322 0002322 00000130611 14155650047 020375 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
import sys
from .utils import InheritedStuff
from .utils import Stuff, DummyModel
from functools import partial
from transitions import Machine, MachineError, State, EventData
from transitions.core import listify, _prep_ordered_arg
from unittest import TestCase, skipIf
import warnings
import weakref
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
def on_exit_A(event):
event.model.exit_A_called = True
def on_exit_B(event):
event.model.exit_B_called = True
class TestTransitions(TestCase):
def setUp(self):
self.stuff = Stuff()
self.machine_cls = Machine
def tearDown(self):
pass
def test_init_machine_with_hella_arguments(self):
states = [
State('State1'),
'State2',
{
'name': 'State3',
'on_enter': 'hello_world'
}
]
transitions = [
{'trigger': 'advance',
'source': 'State2',
'dest': 'State3'
}
]
s = Stuff()
m = s.machine_cls(model=s, states=states, transitions=transitions, initial='State2')
s.advance()
self.assertEqual(s.message, 'Hello World!')
def test_listify(self):
self.assertEqual(listify(4), [4])
self.assertEqual(listify(None), [])
self.assertEqual(listify((4, 5)), (4, 5))
self.assertEqual(listify([1, 3]), [1, 3])
class Foo:
pass
obj = Foo()
proxy = weakref.proxy(obj)
del obj
self.assertEqual(listify(proxy), [proxy])
def test_weakproxy_model(self):
d = DummyModel()
pr = weakref.proxy(d)
self.machine_cls(pr, states=['A', 'B'], transitions=[['go', 'A', 'B']], initial='A')
pr.go()
self.assertTrue(pr.is_B())
def test_property_initial(self):
states = ['A', 'B', 'C', 'D']
# Define with list of dictionaries
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
self.assertEqual(m.initial, 'A')
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='C')
self.assertEqual(m.initial, 'C')
m = self.stuff.machine_cls(states=states, transitions=transitions)
self.assertEqual(m.initial, 'initial')
def test_transition_definitions(self):
states = ['A', 'B', 'C', 'D']
# Define with list of dictionaries
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = Machine(states=states, transitions=transitions, initial='A')
m.walk()
self.assertEqual(m.state, 'B')
# Define with list of lists
transitions = [
['walk', 'A', 'B'],
['run', 'B', 'C'],
['sprint', 'C', 'D']
]
m = Machine(states=states, transitions=transitions, initial='A')
m.to_C()
m.sprint()
self.assertEqual(m.state, 'D')
def test_add_states(self):
s = self.stuff
s.machine.add_state('X')
s.machine.add_state('Y')
s.machine.add_state('Z')
event = s.machine.events['to_{0}'.format(s.state)]
self.assertEqual(1, len(event.transitions['X']))
def test_transitioning(self):
s = self.stuff
s.machine.add_transition('advance', 'A', 'B')
s.machine.add_transition('advance', 'B', 'C')
s.machine.add_transition('advance', 'C', 'D')
s.advance()
self.assertEqual(s.state, 'B')
self.assertFalse(s.is_A())
self.assertTrue(s.is_B())
s.advance()
self.assertEqual(s.state, 'C')
def test_pass_state_instances_instead_of_names(self):
state_A = State('A')
state_B = State('B')
states = [state_A, state_B]
m = Machine(states=states, initial=state_A)
assert m.state == 'A'
m.add_transition('advance', state_A, state_B)
m.advance()
assert m.state == 'B'
state_B2 = State('B', on_enter='this_passes')
with self.assertRaises(ValueError):
m.add_transition('advance2', state_A, state_B2)
m2 = Machine(states=states, initial=state_A.name)
assert m.initial == m2.initial
with self.assertRaises(ValueError):
Machine(states=states, initial=State('A'))
def test_conditions(self):
s = self.stuff
s.machine.add_transition('advance', 'A', 'B', conditions='this_passes')
s.machine.add_transition('advance', 'B', 'C', unless=['this_fails'])
s.machine.add_transition('advance', 'C', 'D', unless=['this_fails',
'this_passes'])
s.advance()
self.assertEqual(s.state, 'B')
s.advance()
self.assertEqual(s.state, 'C')
s.advance()
self.assertEqual(s.state, 'C')
def test_uncallable_callbacks(self):
s = self.stuff
s.machine.add_transition('advance', 'A', 'B', conditions=['property_that_fails', 'is_false'])
# make sure parameters passed by trigger events can be handled
s.machine.add_transition('advance', 'A', 'C', before=['property_that_fails', 'is_false'])
s.advance(level='MaximumSpeed')
self.assertTrue(s.is_C())
def test_conditions_with_partial(self):
def check(result):
return result
s = self.stuff
s.machine.add_transition('advance', 'A', 'B',
conditions=partial(check, True))
s.machine.add_transition('advance', 'B', 'C',
unless=[partial(check, False)])
s.machine.add_transition('advance', 'C', 'D',
unless=[partial(check, False), partial(check, True)])
s.advance()
self.assertEqual(s.state, 'B')
s.advance()
self.assertEqual(s.state, 'C')
s.advance()
self.assertEqual(s.state, 'C')
def test_multiple_add_transitions_from_state(self):
s = self.stuff
s.machine.add_transition(
'advance', 'A', 'B', conditions=['this_fails'])
s.machine.add_transition('advance', 'A', 'C')
s.advance()
self.assertEqual(s.state, 'C')
def test_use_machine_as_model(self):
states = ['A', 'B', 'C', 'D']
m = Machine(states=states, initial='A')
m.add_transition('move', 'A', 'B')
m.add_transition('move_to_C', 'B', 'C')
m.move()
self.assertEqual(m.state, 'B')
def test_state_change_listeners(self):
s = self.stuff
s.machine.add_transition('advance', 'A', 'B')
s.machine.add_transition('reverse', 'B', 'A')
s.machine.on_enter_B('hello_world')
s.machine.on_exit_B('goodbye')
s.advance()
self.assertEqual(s.state, 'B')
self.assertEqual(s.message, 'Hello World!')
s.reverse()
self.assertEqual(s.state, 'A')
self.assertTrue(s.message.startswith('So long'))
def test_before_after_callback_addition(self):
m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A')
m.add_transition('move', 'A', 'B')
trans = m.events['move'].transitions['A'][0]
trans.add_callback('after', 'increase_level')
m.model.move()
self.assertEqual(m.model.level, 2)
def test_before_after_transition_listeners(self):
m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A')
m.add_transition('move', 'A', 'B')
m.add_transition('move', 'B', 'C')
m.before_move('increase_level')
m.model.move()
self.assertEqual(m.model.level, 2)
m.model.move()
self.assertEqual(m.model.level, 3)
def test_prepare(self):
m = Machine(Stuff(), states=['A', 'B', 'C'], initial='A')
m.add_transition('move', 'A', 'B', prepare='increase_level')
m.add_transition('move', 'B', 'C', prepare='increase_level')
m.add_transition('move', 'C', 'A', prepare='increase_level', conditions='this_fails')
m.add_transition('dont_move', 'A', 'C', prepare='increase_level')
m.prepare_move('increase_level')
m.model.move()
self.assertEqual(m.model.state, 'B')
self.assertEqual(m.model.level, 3)
m.model.move()
self.assertEqual(m.model.state, 'C')
self.assertEqual(m.model.level, 5)
# State does not advance, but increase_level still runs
m.model.move()
self.assertEqual(m.model.state, 'C')
self.assertEqual(m.model.level, 7)
# An invalid transition shouldn't execute the callback
try:
m.model.dont_move()
except MachineError as e:
self.assertTrue("Can't trigger event" in str(e))
self.assertEqual(m.model.state, 'C')
self.assertEqual(m.model.level, 7)
def test_state_model_change_listeners(self):
s = self.stuff
s.machine.add_transition('go_e', 'A', 'E')
s.machine.add_transition('go_f', 'E', 'F')
s.machine.on_enter_F('hello_F')
s.go_e()
self.assertEqual(s.state, 'E')
self.assertEqual(s.message, 'I am E!')
s.go_f()
self.assertEqual(s.state, 'F')
self.assertEqual(s.exit_message, 'E go home...')
assert 'I am F!' in s.message
assert 'Hello F!' in s.message
def test_inheritance(self):
states = ['A', 'B', 'C', 'D', 'E']
s = InheritedStuff(states=states, initial='A')
s.add_transition('advance', 'A', 'B', conditions='this_passes')
s.add_transition('advance', 'B', 'C')
s.add_transition('advance', 'C', 'D')
s.advance()
self.assertEqual(s.state, 'B')
self.assertFalse(s.is_A())
self.assertTrue(s.is_B())
s.advance()
self.assertEqual(s.state, 'C')
class NewMachine(Machine):
def __init__(self, *args, **kwargs):
super(NewMachine, self).__init__(*args, **kwargs)
n = NewMachine(states=states, transitions=[['advance', 'A', 'B']], initial='A')
self.assertTrue(n.is_A())
n.advance()
self.assertTrue(n.is_B())
with self.assertRaises(ValueError):
NewMachine(state=['A', 'B'])
def test_send_event_data_callbacks(self):
states = ['A', 'B', 'C', 'D', 'E']
s = Stuff()
# First pass positional and keyword args directly to the callback
m = Machine(model=s, states=states, initial='A', send_event=False,
auto_transitions=True)
m.add_transition(
trigger='advance', source='A', dest='B', before='set_message')
s.advance(message='Hallo. My name is Inigo Montoya.')
self.assertTrue(s.message.startswith('Hallo.'))
s.to_A()
s.advance('Test as positional argument')
self.assertTrue(s.message.startswith('Test as'))
# Now wrap arguments in an EventData instance
m.send_event = True
m.add_transition(
trigger='advance', source='B', dest='C', before='extract_message')
s.advance(message='You killed my father. Prepare to die.')
self.assertTrue(s.message.startswith('You'))
def test_send_event_data_conditions(self):
states = ['A', 'B', 'C', 'D']
s = Stuff()
# First pass positional and keyword args directly to the condition
m = Machine(model=s, states=states, initial='A', send_event=False)
m.add_transition(
trigger='advance', source='A', dest='B',
conditions='this_fails_by_default')
s.advance(boolean=True)
self.assertEqual(s.state, 'B')
# Now wrap arguments in an EventData instance
m.send_event = True
m.add_transition(
trigger='advance', source='B', dest='C',
conditions='extract_boolean')
s.advance(boolean=False)
self.assertEqual(s.state, 'B')
def test_auto_transitions(self):
states = ['A', {'name': 'B'}, State(name='C')]
m = Machine(states=states, initial='A', auto_transitions=True)
m.to_B()
self.assertEqual(m.state, 'B')
m.to_C()
self.assertEqual(m.state, 'C')
m.to_A()
self.assertEqual(m.state, 'A')
# Should fail if auto transitions is off...
m = Machine(states=states, initial='A', auto_transitions=False)
with self.assertRaises(AttributeError):
m.to_C()
def test_ordered_transitions(self):
states = ['beginning', 'middle', 'end']
m = Machine(states=states)
m.add_ordered_transitions()
self.assertEqual(m.state, 'initial')
m.next_state()
self.assertEqual(m.state, 'beginning')
m.next_state()
m.next_state()
self.assertEqual(m.state, 'end')
m.next_state()
self.assertEqual(m.state, 'initial')
# Include initial state in loop
m = Machine(states=states)
m.add_ordered_transitions(loop_includes_initial=False)
m.to_end()
m.next_state()
self.assertEqual(m.state, 'beginning')
# Do not loop transitions
m = Machine(states=states)
m.add_ordered_transitions(loop=False)
m.to_end()
with self.assertRaises(MachineError):
m.next_state()
# Test user-determined sequence and trigger name
m = Machine(states=states, initial='beginning')
m.add_ordered_transitions(['end', 'beginning'], trigger='advance')
m.advance()
self.assertEqual(m.state, 'end')
m.advance()
self.assertEqual(m.state, 'beginning')
# Via init argument
m = Machine(states=states, initial='beginning', ordered_transitions=True)
m.next_state()
self.assertEqual(m.state, 'middle')
# Alter initial state
m = Machine(states=states, initial='middle', ordered_transitions=True)
m.next_state()
self.assertEqual(m.state, 'end')
m.next_state()
self.assertEqual(m.state, 'beginning')
# Partial state machine without the initial state
m = Machine(states=states, initial='beginning')
m.add_ordered_transitions(['middle', 'end'])
self.assertEqual(m.state, 'beginning')
with self.assertRaises(MachineError):
m.next_state()
m.to_middle()
for s in ('end', 'middle', 'end'):
m.next_state()
self.assertEqual(m.state, s)
def test_ordered_transition_error(self):
m = Machine(states=['A'], initial='A')
with self.assertRaises(ValueError):
m.add_ordered_transitions()
m.add_state('B')
m.add_ordered_transitions()
m.add_state('C')
with self.assertRaises(ValueError):
m.add_ordered_transitions(['C'])
def test_ignore_invalid_triggers(self):
a_state = State('A')
transitions = [['a_to_b', 'A', 'B']]
# Exception is triggered by default
b_state = State('B')
m1 = Machine(states=[a_state, b_state], transitions=transitions,
initial='B')
with self.assertRaises(MachineError):
m1.a_to_b()
# Set default value on machine level
m2 = Machine(states=[a_state, b_state], transitions=transitions,
initial='B', ignore_invalid_triggers=True)
m2.a_to_b()
# Exception is suppressed, so this passes
b_state = State('B', ignore_invalid_triggers=True)
m3 = Machine(states=[a_state, b_state], transitions=transitions,
initial='B')
m3.a_to_b()
# Set for some states but not others
new_states = ['C', 'D']
m1.add_states(new_states, ignore_invalid_triggers=True)
m1.to_D()
m1.a_to_b() # passes because exception suppressed for D
m1.to_B()
with self.assertRaises(MachineError):
m1.a_to_b()
# State value overrides machine behaviour
m3 = Machine(states=[a_state, b_state], transitions=transitions,
initial='B', ignore_invalid_triggers=False)
m3.a_to_b()
def test_string_callbacks(self):
m = Machine(states=['A', 'B'],
before_state_change='before_state_change',
after_state_change='after_state_change', send_event=True,
initial='A', auto_transitions=True)
m.before_state_change = MagicMock()
m.after_state_change = MagicMock()
m.to_B()
self.assertTrue(m.before_state_change[0].called)
self.assertTrue(m.after_state_change[0].called)
# after_state_change should have been called with EventData
event_data = m.after_state_change[0].call_args[0][0]
self.assertIsInstance(event_data, EventData)
self.assertTrue(event_data.result)
def test_function_callbacks(self):
before_state_change = MagicMock()
after_state_change = MagicMock()
m = Machine(states=['A', 'B'],
before_state_change=before_state_change,
after_state_change=after_state_change, send_event=True,
initial='A', auto_transitions=True)
m.to_B()
self.assertTrue(m.before_state_change[0].called)
self.assertTrue(m.after_state_change[0].called)
def test_state_callbacks(self):
class Model:
def on_enter_A(self):
pass
def on_exit_A(self):
pass
def on_enter_B(self):
pass
def on_exit_B(self):
pass
states = [State(name='A', on_enter='on_enter_A', on_exit='on_exit_A'),
State(name='B', on_enter='on_enter_B', on_exit='on_exit_B')]
machine = Machine(Model(), states=states)
state_a = machine.get_state('A')
state_b = machine.get_state('B')
self.assertEqual(len(state_a.on_enter), 1)
self.assertEqual(len(state_a.on_exit), 1)
self.assertEqual(len(state_b.on_enter), 1)
self.assertEqual(len(state_b.on_exit), 1)
def test_state_callable_callbacks(self):
class Model:
def __init__(self):
self.exit_A_called = False
self.exit_B_called = False
def on_enter_A(self, event):
pass
def on_enter_B(self, event):
pass
states = [State(name='A', on_enter='on_enter_A', on_exit='tests.test_core.on_exit_A'),
State(name='B', on_enter='on_enter_B', on_exit=on_exit_B),
State(name='C', on_enter='tests.test_core.AAAA')]
model = Model()
machine = Machine(model, states=states, send_event=True, initial='A')
state_a = machine.get_state('A')
state_b = machine.get_state('B')
self.assertEqual(len(state_a.on_enter), 1)
self.assertEqual(len(state_a.on_exit), 1)
self.assertEqual(len(state_b.on_enter), 1)
self.assertEqual(len(state_b.on_exit), 1)
model.to_B()
self.assertTrue(model.exit_A_called)
model.to_A()
self.assertTrue(model.exit_B_called)
with self.assertRaises(AttributeError):
model.to_C()
def test_pickle(self):
import sys
if sys.version_info < (3, 4):
import dill as pickle
else:
import pickle
states = ['A', 'B', 'C', 'D']
# Define with list of dictionaries
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = Machine(states=states, transitions=transitions, initial='A')
m.walk()
dump = pickle.dumps(m)
self.assertIsNotNone(dump)
m2 = pickle.loads(dump)
self.assertEqual(m.state, m2.state)
m2.run()
def test_pickle_model(self):
import sys
if sys.version_info < (3, 4):
import dill as pickle
else:
import pickle
self.stuff.to_B()
dump = pickle.dumps(self.stuff)
self.assertIsNotNone(dump)
model2 = pickle.loads(dump)
self.assertEqual(self.stuff.state, model2.state)
model2.to_F()
def test_queued(self):
states = ['A', 'B', 'C', 'D']
# Define with list of dictionaries
def change_state(machine):
self.assertEqual(machine.state, 'A')
if machine.has_queue:
machine.run(machine=machine)
self.assertEqual(machine.state, 'A')
else:
with self.assertRaises(MachineError):
machine.run(machine=machine)
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B', 'before': change_state},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = Machine(states=states, transitions=transitions, initial='A')
m.walk(machine=m)
self.assertEqual(m.state, 'B')
m = Machine(states=states, transitions=transitions, initial='A', queued=True)
m.walk(machine=m)
self.assertEqual(m.state, 'C')
def test_queued_errors(self):
def before_change(machine):
if machine.has_queue:
machine.to_A(machine)
machine._queued = False
def after_change(machine):
machine.to_C(machine)
states = ['A', 'B', 'C']
transitions = [{'trigger': 'do', 'source': '*', 'dest': 'C',
'before': partial(self.stuff.this_raises, ValueError)}]
m = Machine(states=states, transitions=transitions, queued=True,
before_state_change=before_change, after_state_change=after_change)
with self.assertRaises(MachineError):
m.to_B(machine=m)
with self.assertRaises(ValueError):
m.do(machine=m)
def test_queued_remove(self):
m = self.machine_cls(model=None, states=['A', 'B', 'C'], initial='A', queued=True)
assert_equal = self.assertEqual
class BaseModel:
def on_enter_A(self):
pass
def on_enter_B(self):
pass
def on_enter_C(self):
pass
class SubModel(BaseModel):
def __init__(self):
self.inner = BaseModel()
def on_enter_A(self):
self.to_B()
self.inner.to_B()
def on_enter_B(self):
self.to_C()
self.inner.to_C()
# queue should contain to_B(), inner.to_B(), to_C(), inner.to_C()
assert_equal(4, len(m._transition_queue))
m.remove_model(self)
# since to_B() is currently executed it should still be in the list, to_C should be gone
assert_equal(3, len(m._transition_queue))
def on_enter_C(self):
raise RuntimeError("Event was not cancelled")
model = SubModel()
m.add_model([model, model.inner])
model.to_A()
# test whether models can be removed outside event queue
m.remove_model(model.inner)
self.assertTrue(model.inner.is_C())
def test___getattr___and_identify_callback(self):
m = self.machine_cls(Stuff(), states=['A', 'B', 'C'], initial='A')
m.add_transition('move', 'A', 'B')
m.add_transition('move', 'B', 'C')
callback = m.__getattr__('before_move')
self.assertTrue(callable(callback))
with self.assertRaises(AttributeError):
m.__getattr__('before_no_such_transition')
with self.assertRaises(AttributeError):
m.__getattr__('before_no_such_transition')
with self.assertRaises(AttributeError):
m.__getattr__('__no_such_method__')
with self.assertRaises(AttributeError):
m.__getattr__('')
type, target = m._identify_callback('on_exit_foobar')
self.assertEqual(type, 'on_exit')
self.assertEqual(target, 'foobar')
type, target = m._identify_callback('on_exitfoobar')
self.assertEqual(type, None)
self.assertEqual(target, None)
type, target = m._identify_callback('notacallback_foobar')
self.assertEqual(type, None)
self.assertEqual(target, None)
type, target = m._identify_callback('totallyinvalid')
self.assertEqual(type, None)
self.assertEqual(target, None)
type, target = m._identify_callback('before__foobar')
self.assertEqual(type, 'before')
self.assertEqual(target, '_foobar')
type, target = m._identify_callback('before__this__user__likes__underscores___')
self.assertEqual(type, 'before')
self.assertEqual(target, '_this__user__likes__underscores___')
type, target = m._identify_callback('before_stuff')
self.assertEqual(type, 'before')
self.assertEqual(target, 'stuff')
type, target = m._identify_callback('before_trailing_underscore_')
self.assertEqual(type, 'before')
self.assertEqual(target, 'trailing_underscore_')
type, target = m._identify_callback('before_')
self.assertIs(type, None)
self.assertIs(target, None)
type, target = m._identify_callback('__')
self.assertIs(type, None)
self.assertIs(target, None)
type, target = m._identify_callback('')
self.assertIs(type, None)
self.assertIs(target, None)
def test_state_and_transition_with_underscore(self):
m = Machine(Stuff(), states=['_A_', '_B_', '_C_'], initial='_A_')
m.add_transition('_move_', '_A_', '_B_', prepare='increase_level')
m.add_transition('_after_', '_B_', '_C_', prepare='increase_level')
m.add_transition('_on_exit_', '_C_', '_A_', prepare='increase_level', conditions='this_fails')
m.model._move_()
self.assertEqual(m.model.state, '_B_')
self.assertEqual(m.model.level, 2)
m.model._after_()
self.assertEqual(m.model.state, '_C_')
self.assertEqual(m.model.level, 3)
# State does not advance, but increase_level still runs
m.model._on_exit_()
self.assertEqual(m.model.state, '_C_')
self.assertEqual(m.model.level, 4)
def test_callback_identification(self):
m = Machine(Stuff(), states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A')
m.add_transition('transition', 'A', 'B', before='increase_level')
m.add_transition('after', 'B', 'C', before='increase_level')
m.add_transition('on_exit_A', 'C', 'D', before='increase_level', conditions='this_fails')
m.add_transition('check', 'C', 'E', before='increase_level')
m.add_transition('prepare', 'E', 'F', before='increase_level')
m.add_transition('before', 'F', 'A', before='increase_level')
m.before_transition('increase_level')
m.before_after('increase_level')
m.before_on_exit_A('increase_level')
m.after_check('increase_level')
m.before_prepare('increase_level')
m.before_before('increase_level')
m.model.transition()
self.assertEqual(m.model.state, 'B')
self.assertEqual(m.model.level, 3)
m.model.after()
self.assertEqual(m.model.state, 'C')
self.assertEqual(m.model.level, 5)
m.model.on_exit_A()
self.assertEqual(m.model.state, 'C')
self.assertEqual(m.model.level, 5)
m.model.check()
self.assertEqual(m.model.state, 'E')
self.assertEqual(m.model.level, 7)
m.model.prepare()
self.assertEqual(m.model.state, 'F')
self.assertEqual(m.model.level, 9)
m.model.before()
self.assertEqual(m.model.state, 'A')
self.assertEqual(m.model.level, 11)
# An invalid transition shouldn't execute the callback
with self.assertRaises(MachineError):
m.model.on_exit_A()
def test_process_trigger(self):
m = Machine(states=['raw', 'processed'], initial='raw')
m.add_transition('process', 'raw', 'processed')
m.process()
self.assertEqual(m.state, 'processed')
def test_multiple_models(self):
s1, s2 = Stuff(), Stuff()
states = ['A', 'B', 'C']
m = Machine(model=[s1, s2], states=states,
initial=states[0])
self.assertEqual(len(m.models), 2)
self.assertEqual(len(m.model), 2)
m.add_transition('advance', 'A', 'B')
s1.advance()
self.assertEqual(s1.state, 'B')
self.assertEqual(s2.state, 'A')
m = Machine(model=s1, states=states,
initial=states[0])
# for backwards compatibility model should return a model instance
# rather than a list
self.assertNotIsInstance(m.model, list)
def test_dispatch(self):
s1, s2 = Stuff(), Stuff()
states = ['A', 'B', 'C']
m = Machine(model=s1, states=states, ignore_invalid_triggers=True,
initial=states[0], transitions=[['go', 'A', 'B'], ['go', 'B', 'C']])
m.add_model(s2, initial='B')
m.dispatch('go')
self.assertEqual(s1.state, 'B')
self.assertEqual(s2.state, 'C')
def test_remove_model(self):
m = self.machine_cls()
self.assertIn(m, m.models)
m.remove_model(m)
self.assertNotIn(m, m.models)
def test_string_trigger(self):
def return_value(value):
return value
class Model:
def trigger(self, value):
return value
self.stuff.machine.add_transition('do', '*', 'C')
self.stuff.trigger('do')
self.assertTrue(self.stuff.is_C())
self.stuff.machine.add_transition('maybe', 'C', 'A', conditions=return_value)
self.assertFalse(self.stuff.trigger('maybe', value=False))
self.assertTrue(self.stuff.trigger('maybe', value=True))
self.assertTrue(self.stuff.is_A())
with self.assertRaises(AttributeError):
self.stuff.trigger('not_available')
with self.assertRaises(MachineError):
self.stuff.trigger('maybe')
model = Model()
m = Machine(model=model)
self.assertEqual(model.trigger(5), 5)
self.stuff.machine.add_transition('do_raise_keyerror', '*', 'C',
before=partial(self.stuff.this_raises, KeyError))
with self.assertRaises(KeyError):
self.stuff.trigger('do_raise_keyerror')
self.stuff.machine.get_model_state(self.stuff).ignore_invalid_triggers = True
self.stuff.trigger('should_not_raise_anything')
self.stuff.trigger('to_A')
self.assertTrue(self.stuff.is_A())
self.stuff.machine.ignore_invalid_triggers = True
self.stuff.trigger('should_not_raise_anything')
def test_get_triggers(self):
states = ['A', 'B', 'C']
transitions = [['a2b', 'A', 'B'],
['a2c', 'A', 'C'],
['c2b', 'C', 'B']]
machine = Machine(states=states, transitions=transitions, initial='A', auto_transitions=False)
self.assertEqual(len(machine.get_triggers('A')), 2)
self.assertEqual(len(machine.get_triggers('B')), 0)
self.assertEqual(len(machine.get_triggers('C')), 1)
# self stuff machine should have to-transitions to every state
m = self.stuff.machine
self.assertEqual(len(m.get_triggers('B')), len(m.states))
trigger_name = m.get_triggers('B')
trigger_state = m.get_triggers(m.states['B'])
self.assertEqual(trigger_name, trigger_state)
def test_skip_override(self):
local_mock = MagicMock()
class Model(object):
def go(self):
local_mock()
model = Model()
transitions = [['go', 'A', 'B'], ['advance', 'A', 'B']]
m = self.stuff.machine_cls(model=model, states=['A', 'B'], transitions=transitions, initial='A')
model.go()
self.assertEqual(model.state, 'A')
self.assertTrue(local_mock.called)
model.advance()
self.assertEqual(model.state, 'B')
model.to_A()
model.trigger('go')
self.assertEqual(model.state, 'B')
@skipIf(sys.version_info < (3, ),
"String-checking disabled on PY-2 because is different")
def test_repr(self):
def a_condition(event_data):
self.assertRegex(
str(event_data.transition.conditions),
r"\["
r".a_condition at [^>]+>\)@\d+>\]")
return True
# No transition has been assigned to EventData yet
def check_prepare_repr(event_data):
self.assertRegex(
str(event_data),
r"', "
r"None\)@\d+>")
def check_before_repr(event_data):
self.assertRegex(
str(event_data),
r"', "
r"\)@\d+>")
m.checked = True
m = Machine(states=['A', 'B'],
prepare_event=check_prepare_repr,
before_state_change=check_before_repr, send_event=True,
initial='A')
m.add_transition('do_strcheck', 'A', 'B', conditions=a_condition)
self.assertTrue(m.do_strcheck())
self.assertIn('checked', vars(m))
def test_machine_prepare(self):
global_mock = MagicMock()
local_mock = MagicMock()
def global_callback():
global_mock()
def local_callback():
local_mock()
def always_fails():
return False
transitions = [
{'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback},
{'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback},
{'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback},
{'trigger': 'go', 'source': 'A', 'dest': 'B', 'conditions': always_fails, 'prepare': local_callback},
{'trigger': 'go', 'source': 'A', 'dest': 'B', 'prepare': local_callback},
]
m = Machine(states=['A', 'B'], transitions=transitions,
prepare_event=global_callback, initial='A')
m.go()
self.assertEqual(global_mock.call_count, 1)
self.assertEqual(local_mock.call_count, len(transitions))
def test_machine_finalize(self):
finalize_mock = MagicMock()
def always_fails(event_data):
return False
transitions = [
{'trigger': 'go', 'source': 'A', 'dest': 'B'},
{'trigger': 'planA', 'source': 'B', 'dest': 'A', 'conditions': always_fails},
{'trigger': 'planB', 'source': 'B', 'dest': 'A',
'conditions': partial(self.stuff.this_raises, RuntimeError)}
]
m = self.stuff.machine_cls(states=['A', 'B'], transitions=transitions,
finalize_event=finalize_mock, initial='A', send_event=True)
m.go()
self.assertEqual(finalize_mock.call_count, 1)
m.planA()
event_data = finalize_mock.call_args[0][0]
self.assertIsInstance(event_data, EventData)
self.assertEqual(finalize_mock.call_count, 2)
self.assertFalse(event_data.result)
with self.assertRaises(RuntimeError):
m.planB()
m.finalize_event.append(partial(self.stuff.this_raises, ValueError))
# ValueError in finalize should be suppressed
# but mock should have been called anyway
with self.assertRaises(RuntimeError):
m.planB()
self.assertEqual(finalize_mock.call_count, 4)
def test_machine_finalize_exception(self):
def finalize_callback(event):
self.assertIsInstance(event.error, ZeroDivisionError)
m = self.stuff.machine_cls(states=['A', 'B'], send_event=True, initial='A',
before_state_change=partial(self.stuff.this_raises, ZeroDivisionError),
finalize_event=finalize_callback)
with self.assertRaises(ZeroDivisionError):
m.to_B()
def test_prep_ordered_arg(self):
self.assertTrue(len(_prep_ordered_arg(3, None)) == 3)
self.assertTrue(all(a is None for a in _prep_ordered_arg(3, None)))
with self.assertRaises(ValueError):
_prep_ordered_arg(3, [None, None])
def test_ordered_transition_callback(self):
class Model:
def __init__(self):
self.flag = False
def make_true(self):
self.flag = True
model = Model()
states = ['beginning', 'middle', 'end']
transits = [None, None, 'make_true']
m = Machine(model, states, initial='beginning')
m.add_ordered_transitions(before=transits)
model.next_state()
self.assertFalse(model.flag)
model.next_state()
model.next_state()
self.assertTrue(model.flag)
def test_ordered_transition_condition(self):
class Model:
def __init__(self):
self.blocker = False
def check_blocker(self):
return self.blocker
model = Model()
states = ['beginning', 'middle', 'end']
m = Machine(model, states, initial='beginning')
m.add_ordered_transitions(conditions=[None, None, 'check_blocker'])
model.to_end()
self.assertFalse(model.next_state())
model.blocker = True
self.assertTrue(model.next_state())
def test_get_transitions(self):
states = ['A', 'B', 'C', 'D']
m = self.machine_cls(states=states, initial='A', auto_transitions=False)
m.add_transition('go', ['A', 'B', 'C'], 'D')
m.add_transition('run', 'A', 'D')
self.assertEqual(
{(t.source, t.dest) for t in m.get_transitions('go')},
{('A', 'D'), ('B', 'D'), ('C', 'D')})
self.assertEqual(
[(t.source, t.dest)
for t in m.get_transitions(source='A', dest='D')],
[('A', 'D'), ('A', 'D')])
self.assertEqual(
sorted([(t.source, t.dest)
for t in m.get_transitions(dest='D')]),
[('A', 'D'), ('A', 'D'), ('B', 'D'), ('C', 'D')])
self.assertEqual(
[(t.source, t.dest)
for t in m.get_transitions(source=m.states['A'], dest=m.states['D'])],
[('A', 'D'), ('A', 'D')])
self.assertEqual(
sorted([(t.source, t.dest)
for t in m.get_transitions(dest=m.states['D'])]),
[('A', 'D'), ('A', 'D'), ('B', 'D'), ('C', 'D')])
def test_remove_transition(self):
self.stuff.machine.add_transition('go', ['A', 'B', 'C'], 'D')
self.stuff.machine.add_transition('walk', 'A', 'B')
self.stuff.go()
self.assertEqual(self.stuff.state, 'D')
self.stuff.to_A()
self.stuff.machine.remove_transition('go', source='A')
with self.assertRaises(MachineError):
self.stuff.go()
self.stuff.machine.add_transition('go', 'A', 'D')
self.stuff.walk()
self.stuff.go()
self.assertEqual(self.stuff.state, 'D')
self.stuff.to_C()
self.stuff.machine.remove_transition('go', dest='D')
self.assertFalse(hasattr(self.stuff, 'go'))
def test_reflexive_transition(self):
self.stuff.machine.add_transition('reflex', ['A', 'B'], '=', after='increase_level')
self.assertEqual(self.stuff.state, 'A')
self.stuff.reflex()
self.assertEqual(self.stuff.state, 'A')
self.assertEqual(self.stuff.level, 2)
self.stuff.to_B()
self.assertEqual(self.stuff.state, 'B')
self.stuff.reflex()
self.assertEqual(self.stuff.state, 'B')
self.assertEqual(self.stuff.level, 3)
self.stuff.to_C()
with self.assertRaises(MachineError):
self.stuff.reflex()
self.assertEqual(self.stuff.level, 3)
def test_internal_transition(self):
m = Machine(Stuff(), states=['A', 'B'], initial='A')
m.add_transition('move', 'A', None, prepare='increase_level')
m.model.move()
self.assertEqual(m.model.state, 'A')
self.assertEqual(m.model.level, 2)
def test_dynamic_model_state_attribute(self):
class Model:
def __init__(self):
self.status = None
self.state = 'some_value'
m = self.machine_cls(Model(), states=['A', 'B'], initial='A', model_attribute='status')
self.assertEqual(m.model.status, 'A')
self.assertEqual(m.model.state, 'some_value')
m.add_transition('move', 'A', 'B')
m.model.move()
self.assertEqual(m.model.status, 'B')
self.assertEqual(m.model.state, 'some_value')
def test_multiple_machines_per_model(self):
class Model:
def __init__(self):
self.car_state = None
self.driver_state = None
instance = Model()
machine_a = Machine(instance, states=['A', 'B'], initial='A', model_attribute='car_state')
machine_a.add_transition('accelerate_car', 'A', 'B')
machine_b = Machine(instance, states=['A', 'B'], initial='B', model_attribute='driver_state')
machine_b.add_transition('driving', 'B', 'A')
assert instance.car_state == 'A'
assert instance.driver_state == 'B'
assert instance.is_car_state_A()
assert instance.is_driver_state_B()
instance.accelerate_car()
assert instance.car_state == 'B'
assert instance.driver_state == 'B'
assert not instance.is_car_state_A()
assert instance.is_car_state_B()
instance.driving()
assert instance.driver_state == 'A'
assert instance.car_state == 'B'
assert instance.is_driver_state_A()
assert not instance.is_driver_state_B()
assert instance.to_driver_state_B()
assert instance.driver_state == 'B'
def test_initial_not_registered(self):
m1 = self.machine_cls(states=['A', 'B'], initial=self.machine_cls.state_cls('C'))
self.assertTrue(m1.is_C())
self.assertTrue('C' in m1.states)
def test_trigger_name_cannot_be_equal_to_model_attribute(self):
m = self.machine_cls(states=['A', 'B'])
with self.assertRaises(ValueError):
m.add_transition(m.model_attribute, "A", "B")
def test_new_state_in_enter_callback(self):
machine = self.machine_cls(states=['A', 'B'], initial='A')
def on_enter_B():
state = self.machine_cls.state_cls(name='C')
machine.add_state(state)
machine.to_C()
machine.on_enter_B(on_enter_B)
machine.to_B()
def test_on_exception_callback(self):
mock = MagicMock()
def on_exception(event_data):
self.assertIsInstance(event_data.error, ValueError)
mock()
m = self.machine_cls(states=['A', 'B'], initial='A', send_event=True,
after_state_change=partial(self.stuff.this_raises, ValueError))
with self.assertRaises(ValueError):
m.to_B()
m.on_exception.append(on_exception)
m.to_B()
self.assertTrue(mock.called)
class TestWarnings(TestCase):
def test_multiple_machines_per_model(self):
class Model:
def __init__(self):
self.car_state = None
self.driver_state = None
instance = Model()
with warnings.catch_warnings(record=True) as w:
warnings.filterwarnings(action='default', message=r".*transitions version.*", category=DeprecationWarning)
machine_a = Machine(instance, states=['A', 'B'], initial='A', model_attribute='car_state')
machine_b = Machine(instance, states=['A', 'B'], initial='B', model_attribute='driver_state')
self.assertEqual(0, len(w))
self.assertTrue(instance.is_A())
self.assertTrue(instance.is_A())
self.assertEqual(1, len(w))
self.assertEqual(w[0].category, DeprecationWarning)
instance.to_B()
self.assertEqual('B', instance.car_state)
self.assertFalse(instance.is_A())
self.assertEqual(2, len(w))
self.assertEqual(w[1].category, DeprecationWarning)
transitions-0.8.10+3/tests/test_markup.py 0000644 0002322 0002322 00000017024 14155650047 020746 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from transitions.core import Enum
from transitions.extensions.markup import MarkupMachine, rep
from transitions.extensions import MachineFactory
from transitions.extensions.factory import HierarchicalMarkupMachine
from .utils import Stuff
from functools import partial
from unittest import TestCase, skipIf
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
try:
import enum
except ImportError:
enum = None
class SimpleModel(object):
def after_func(self):
pass
class TestRep(TestCase):
def test_rep_string(self):
self.assertEqual(rep("string"), "string")
def test_rep_function(self):
def check():
return True
self.assertTrue(check())
self.assertEqual(rep(check, MarkupMachine.format_references), "check")
def test_rep_partial_no_args_no_kwargs(self):
def check():
return True
pcheck = partial(check)
self.assertTrue(pcheck())
self.assertEqual(rep(pcheck, MarkupMachine.format_references), "check()")
def test_rep_partial_with_args(self):
def check(result):
return result
pcheck = partial(check, True)
self.assertTrue(pcheck())
self.assertEqual(rep(pcheck, MarkupMachine.format_references), "check(True)")
def test_rep_partial_with_kwargs(self):
def check(result=True):
return result
pcheck = partial(check, result=True)
self.assertTrue(pcheck())
self.assertEqual(rep(pcheck, MarkupMachine.format_references), "check(result=True)")
def test_rep_partial_with_args_and_kwargs(self):
def check(result, doublecheck=True):
return result == doublecheck
pcheck = partial(check, True, doublecheck=True)
self.assertTrue(pcheck())
self.assertEqual(rep(pcheck, MarkupMachine.format_references), "check(True, doublecheck=True)")
def test_rep_callable_class(self):
class Check(object):
def __init__(self, result):
self.result = result
def __call__(self):
return self.result
def __repr__(self):
return "%s(%r)" % (type(self).__name__, self.result)
ccheck = Check(True)
self.assertTrue(ccheck())
self.assertEqual(rep(ccheck, MarkupMachine.format_references), "Check(True)")
class TestMarkupMachine(TestCase):
def setUp(self):
self.machine_cls = MarkupMachine
self.states = ['A', 'B', 'C', 'D']
self.transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
self.num_trans = len(self.transitions)
self.num_auto = len(self.states) ** 2
def test_markup_self(self):
m1 = self.machine_cls(states=self.states, transitions=self.transitions, initial='A')
m1.walk()
m2 = self.machine_cls(markup=m1.markup)
self.assertTrue(m1.state == m2.state or m1.state.name == m2.state)
self.assertEqual(len(m1.models), len(m2.models))
self.assertEqual(sorted(m1.states.keys()), sorted(m2.states.keys()))
self.assertEqual(sorted(m1.events.keys()), sorted(m2.events.keys()))
m2.run()
m2.sprint()
self.assertNotEqual(m1.state, m2.state)
def test_markup_model(self):
model1 = SimpleModel()
m1 = self.machine_cls(model1, states=self.states, transitions=self.transitions, initial='A')
model1.walk()
m2 = self.machine_cls(markup=m1.markup)
model2 = m2.models[0]
self.assertIsInstance(model2, SimpleModel)
self.assertEqual(len(m1.models), len(m2.models))
self.assertTrue(model1.state == model2.state or model1.state.name == model2.state)
self.assertEqual(sorted(m1.states.keys()), sorted(m2.states.keys()))
self.assertEqual(sorted(m1.events.keys()), sorted(m2.events.keys()))
def test_conditions_unless(self):
s = Stuff(machine_cls=self.machine_cls)
s.machine.add_transition('go', 'A', 'B', conditions='this_passes',
unless=['this_fails', 'this_fails_by_default'])
t = s.machine.markup['transitions']
self.assertEqual(len(t), 1)
self.assertEqual(t[0]['trigger'], 'go')
self.assertEqual(len(t[0]['conditions']), 1)
self.assertEqual(len(t[0]['unless']), 2)
def test_auto_transitions(self):
m1 = self.machine_cls(states=self.states, transitions=self.transitions, initial='A')
m2 = self.machine_cls(states=self.states, transitions=self.transitions, initial='A',
auto_transitions_markup=True)
self.assertEqual(len(m1.markup.get('transitions')), self.num_trans)
self.assertEqual(len(m2.markup.get('transitions')), self.num_trans + self.num_auto)
m1.add_transition('go', 'A', 'B')
m2.add_transition('go', 'A', 'B')
self.num_trans += 1
self.assertEqual(len(m1.markup.get('transitions')), self.num_trans)
self.assertEqual(len(m2.markup.get('transitions')), self.num_trans + self.num_auto)
m1.auto_transitions_markup = True
m2.auto_transitions_markup = False
self.assertEqual(len(m1.markup.get('transitions')), self.num_trans + self.num_auto)
self.assertEqual(len(m2.markup.get('transitions')), self.num_trans)
class TestMarkupHierarchicalMachine(TestMarkupMachine):
def setUp(self):
self.states = ['A', 'B', {'name': 'C',
'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}]
self.transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'C_1'},
{'trigger': 'run', 'source': 'C_1', 'dest': 'C_3_a'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'B'}
]
# MarkupMachine cannot be imported via get_predefined as of now
# We want to be able to run these tests without (py)graphviz
self.machine_cls = HierarchicalMarkupMachine
self.num_trans = len(self.transitions)
self.num_auto = len(self.states) * 9
def test_nested_definitions(self):
states = [{'name': 'A'},
{'name': 'B'},
{'name': 'C',
'children': [
{'name': '1'},
{'name': '2'}],
'transitions': [
{'trigger': 'go',
'source': '1',
'dest': '2'}],
'initial': '2'}]
machine = self.machine_cls(states=states, initial='A', auto_transitions=False, name='TestMachine')
markup = {k: v for k, v in machine.markup.items() if v and k != 'models'}
self.assertEqual(dict(initial='A', states=states, name='TestMachine'), markup)
@skipIf(enum is None, "enum is not available")
class TestMarkupMachineEnum(TestMarkupMachine):
class States(Enum):
A = 1
B = 2
C = 3
D = 4
def setUp(self):
self.machine_cls = MarkupMachine
self.states = TestMarkupMachineEnum.States
self.transitions = [
{'trigger': 'walk', 'source': self.states.A, 'dest': self.states.B},
{'trigger': 'run', 'source': self.states.B, 'dest': self.states.C},
{'trigger': 'sprint', 'source': self.states.C, 'dest': self.states.D}
]
self.num_trans = len(self.transitions)
self.num_auto = len(self.states)**2
transitions-0.8.10+3/tests/test_threading.py 0000644 0002322 0002322 00000024603 14155650047 021415 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
import time
from threading import Thread
import logging
from transitions.extensions import MachineFactory
from .test_nesting import TestNestedTransitions as TestsNested
from .test_core import TestTransitions as TestCore
from .utils import Stuff, DummyModel, SomeContext
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
logger = logging.getLogger(__name__)
logger.addHandler(logging.NullHandler())
def heavy_processing():
time.sleep(1)
def heavy_checking():
time.sleep(0.5)
return False
class TestLockedTransitions(TestCore):
def setUp(self):
self.machine_cls = MachineFactory.get_predefined(locked=True)
self.stuff = Stuff(machine_cls=self.machine_cls)
self.stuff.heavy_processing = heavy_processing
self.stuff.machine.add_transition('forward', 'A', 'B', before='heavy_processing')
def tearDown(self):
pass
def test_thread_access(self):
thread = Thread(target=self.stuff.forward)
thread.start()
# give thread some time to start
time.sleep(0.01)
self.assertTrue(self.stuff.is_B())
def test_parallel_access(self):
thread = Thread(target=self.stuff.forward)
thread.start()
# give thread some time to start
time.sleep(0.01)
self.stuff.to_C()
# if 'forward' has not been locked, it is still running
# we have to wait to be sure it is done
time.sleep(1)
self.assertEqual(self.stuff.state, "C")
def test_parallel_deep(self):
self.stuff.machine.add_transition('deep', source='*', dest='C', after='to_D')
thread = Thread(target=self.stuff.deep)
thread.start()
time.sleep(0.01)
self.stuff.to_C()
time.sleep(1)
self.assertEqual(self.stuff.state, "C")
def test_conditional_access(self):
self.stuff.heavy_checking = heavy_checking # checking takes 1s and returns False
self.stuff.machine.add_transition('advance', 'A', 'B', conditions='heavy_checking')
self.stuff.machine.add_transition('advance', 'A', 'D')
t = Thread(target=self.stuff.advance)
t.start()
time.sleep(0.1)
logger.info('Check if state transition done...')
# Thread will release lock before Transition is finished
res = self.stuff.is_D()
self.assertTrue(res)
def test_pickle(self):
import sys
if sys.version_info < (3, 4):
import dill as pickle
else:
import pickle
# go to non initial state B
self.stuff.to_B()
# pickle Stuff model
dump = pickle.dumps(self.stuff)
self.assertIsNotNone(dump)
stuff2 = pickle.loads(dump)
self.assertTrue(stuff2.is_B())
# check if machines of stuff and stuff2 are truly separated
stuff2.to_A()
self.stuff.to_C()
self.assertTrue(stuff2.is_A())
thread = Thread(target=stuff2.forward)
thread.start()
# give thread some time to start
time.sleep(0.01)
# both objects should be in different states
# and also not share locks
begin = time.time()
# stuff should not be locked and execute fast
self.assertTrue(self.stuff.is_C())
fast = time.time()
# stuff2 should be locked and take about 1 second
# to be executed
self.assertTrue(stuff2.is_B())
blocked = time.time()
self.assertAlmostEqual(fast - begin, 0, delta=0.1)
self.assertAlmostEqual(blocked - begin, 1, delta=0.1)
def test_context_managers(self):
class CounterContext(object):
def __init__(self):
self.counter = 0
self.level = 0
self.max = 0
super(CounterContext, self).__init__()
def __enter__(self):
self.counter += 1
self.level += 1
self.max = max(self.level, self.max)
def __exit__(self, *exc):
self.level -= 1
M = MachineFactory.get_predefined(locked=True)
c = CounterContext()
m = M(states=['A', 'B', 'C', 'D'], transitions=[['reset', '*', 'A']], initial='A', machine_context=c)
m.get_triggers('A')
self.assertEqual(c.max, 1) # was 3 before
self.assertEqual(c.counter, 4) # was 72 (!) before
# This test has been used to quantify the changes made in locking in version 0.5.0.
# See https://github.com/tyarkoni/transitions/issues/167 for the results.
# def test_performance(self):
# import timeit
# states = ['A', 'B', 'C']
# transitions = [['go', 'A', 'B'], ['go', 'B', 'C'], ['go', 'C', 'A']]
#
# M1 = MachineFactory.get_predefined()
# M2 = MachineFactory.get_predefined(locked=True)
#
# def test_m1():
# m1 = M1(states=states, transitions=transitions, initial='A')
# m1.get_triggers('A')
#
# def test_m2():
# m2 = M2(states=states, transitions=transitions, initial='A')
# m2.get_triggers('A')
#
# t1 = timeit.timeit(test_m1, number=20000)
# t2 = timeit.timeit(test_m2, number=20000)
# self.assertAlmostEqual(t2/t1, 1, delta=0.5)
class TestMultipleContexts(TestCore):
def setUp(self):
self.event_list = []
self.s1 = DummyModel()
self.c1 = SomeContext(event_list=self.event_list)
self.c2 = SomeContext(event_list=self.event_list)
self.c3 = SomeContext(event_list=self.event_list)
self.c4 = SomeContext(event_list=self.event_list)
self.machine_cls = MachineFactory.get_predefined(locked=True)
self.stuff = Stuff(machine_cls=self.machine_cls, extra_kwargs={
'machine_context': [self.c1, self.c2]
})
self.stuff.machine.add_model(self.s1, model_context=[self.c3, self.c4])
del self.event_list[:]
self.stuff.machine.add_transition('forward', 'A', 'B')
def tearDown(self):
self.stuff.machine.remove_model(self.s1)
def test_ordering(self):
self.stuff.forward()
# There are a lot of internal enter/exits, but the key is that the outermost are in the expected order
self.assertEqual((self.c1, "enter"), self.event_list[0])
self.assertEqual((self.c2, "enter"), self.event_list[1])
self.assertEqual((self.c2, "exit"), self.event_list[-2])
self.assertEqual((self.c1, "exit"), self.event_list[-1])
def test_model_context(self):
self.s1.forward()
self.assertEqual((self.c1, "enter"), self.event_list[0])
self.assertEqual((self.c2, "enter"), self.event_list[1])
# Since there are a lot of internal enter/exits, we don't actually know how deep in the stack
# to look for these. Should be able to correct when https://github.com/tyarkoni/transitions/issues/167
self.assertIn((self.c3, "enter"), self.event_list)
self.assertIn((self.c4, "enter"), self.event_list)
self.assertIn((self.c4, "exit"), self.event_list)
self.assertIn((self.c3, "exit"), self.event_list)
self.assertEqual((self.c2, "exit"), self.event_list[-2])
self.assertEqual((self.c1, "exit"), self.event_list[-1])
# Same as TestLockedTransition but with LockedHierarchicalMachine
class TestLockedHierarchicalTransitions(TestsNested, TestLockedTransitions):
def setUp(self):
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]},
'D', 'E', 'F']
self.machine_cls = MachineFactory.get_predefined(locked=True, nested=True)
self.state_cls = self.machine_cls.state_cls
self.state_cls.separator = '_'
self.stuff = Stuff(states, machine_cls=self.machine_cls)
self.stuff.heavy_processing = heavy_processing
self.stuff.machine.add_transition('forward', '*', 'B', before='heavy_processing')
def test_parallel_access(self):
thread = Thread(target=self.stuff.forward)
thread.start()
# give thread some time to start
time.sleep(0.01)
self.stuff.to_C()
# if 'forward' has not been locked, it is still running
# we have to wait to be sure it is done
time.sleep(1)
self.assertEqual(self.stuff.state, "C")
def test_callbacks(self):
class MachineModel(self.stuff.machine_cls):
def __init__(self):
self.mock = MagicMock()
super(MachineModel, self).__init__(self, states=['A', 'B', 'C'])
def on_enter_A(self):
self.mock()
model = MachineModel()
model.to_A()
self.assertTrue(model.mock.called)
def test_pickle(self):
import sys
if sys.version_info < (3, 4):
import dill as pickle
else:
import pickle
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]},
'D', 'E', 'F']
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
m.heavy_processing = heavy_processing
m.add_transition('forward', 'A', 'B', before='heavy_processing')
# # go to non initial state B
m.to_B()
# pickle Stuff model
dump = pickle.dumps(m)
self.assertIsNotNone(dump)
m2 = pickle.loads(dump)
self.assertTrue(m2.is_B())
m2.to_C_3_a()
m2.to_C_3_b()
# check if machines of stuff and stuff2 are truly separated
m2.to_A()
m.to_C()
self.assertTrue(m2.is_A())
thread = Thread(target=m2.forward)
thread.start()
# give thread some time to start
time.sleep(0.01)
# both objects should be in different states
# and also not share locks
begin = time.time()
# stuff should not be locked and execute fast
self.assertTrue(m.is_C())
fast = time.time()
# stuff2 should be locked and take about 1 second
# to be executed
self.assertTrue(m2.is_B())
blocked = time.time()
self.assertAlmostEqual(fast - begin, 0, delta=0.1)
self.assertAlmostEqual(blocked - begin, 1, delta=0.1)
transitions-0.8.10+3/tests/test_graphviz.py 0000644 0002322 0002322 00000041263 14155650047 021303 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from .utils import Stuff, DummyModel
from .test_core import TestTransitions
from transitions.extensions import MachineFactory
from transitions.extensions.nesting import NestedState
from transitions.extensions.states import add_state_features, Timeout, Tags
from unittest import skipIf
import tempfile
import os
import re
try:
# Just to skip tests if graphviz not installed
import graphviz as pgv # @UnresolvedImport
except ImportError: # pragma: no cover
pgv = None
@skipIf(pgv is None, 'Graph diagram test requires graphviz.')
class TestDiagrams(TestTransitions):
machine_cls = MachineFactory.get_predefined(graph=True)
use_pygraphviz = False
def parse_dot(self, graph):
if self.use_pygraphviz:
dot = graph.string()
else:
dot = graph.source
nodes = []
edges = []
for line in dot.split('\n'):
if '->' in line:
src, rest = line.split('->')
dst, attr = rest.split(None, 1)
nodes.append(src.strip().replace('"', ''))
nodes.append(dst)
edges.append(attr)
return dot, set(nodes), edges
def tearDown(self):
pass
# for m in ['pygraphviz', 'graphviz']:
# if 'transitions.extensions.diagrams_' + m in sys.modules:
# del sys.modules['transitions.extensions.diagrams_' + m]
def setUp(self):
self.stuff = Stuff(machine_cls=self.machine_cls, extra_kwargs={'use_pygraphviz': self.use_pygraphviz})
self.states = ['A', 'B', 'C', 'D']
self.transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D', 'conditions': 'is_fast'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'B'}
]
def test_diagram(self):
m = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions=False,
title='a test', use_pygraphviz=self.use_pygraphviz)
graph = m.get_graph()
self.assertIsNotNone(graph)
self.assertTrue(graph.directed)
_, nodes, edges = self.parse_dot(graph)
# Test that graph properties match the Machine
self.assertEqual(set(m.states.keys()), nodes)
self.assertEqual(len(edges), len(self.transitions))
for e in edges:
# label should be equivalent to the event name
self.assertIsNotNone(getattr(m, re.match(r'\[label=([^\]]+)\]', e).group(1)))
# write diagram to temp file
target = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
graph.draw(target.name, format='png', prog='dot')
self.assertTrue(os.path.getsize(target.name) > 0)
# backwards compatibility check
m.get_graph().draw(target.name, format='png', prog='dot')
self.assertTrue(os.path.getsize(target.name) > 0)
# cleanup temp file
target.close()
os.unlink(target.name)
def test_transition_custom_model(self):
m = self.machine_cls(model=None, states=self.states, transitions=self.transitions, initial='A',
auto_transitions=False, title='a test', use_pygraphviz=self.use_pygraphviz)
model = DummyModel()
m.add_model(model)
model.walk()
def test_add_custom_state(self):
m = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions=False,
title='a test', use_pygraphviz=self.use_pygraphviz)
m.add_state('X')
m.add_transition('foo', '*', 'X')
m.foo()
def test_if_multiple_edges_are_supported(self):
transitions = [
['event_0', 'a', 'b'],
['event_1', 'a', 'b'],
['event_2', 'a', 'b'],
['event_3', 'a', 'b'],
]
m = self.machine_cls(
states=['a', 'b'],
transitions=transitions,
initial='a',
auto_transitions=False,
use_pygraphviz=self.use_pygraphviz
)
graph = m.get_graph()
self.assertIsNotNone(graph)
self.assertTrue("digraph" in str(graph))
triggers = [transition[0] for transition in transitions]
for trigger in triggers:
self.assertTrue(trigger in str(graph))
def test_multi_model_state(self):
m1 = Stuff(machine_cls=None, extra_kwargs={'use_pygraphviz': self.use_pygraphviz})
m2 = Stuff(machine_cls=None, extra_kwargs={'use_pygraphviz': self.use_pygraphviz})
m = self.machine_cls(model=[m1, m2], states=self.states, transitions=self.transitions, initial='A',
use_pygraphviz=self.use_pygraphviz)
m1.walk()
self.assertEqual(m.model_graphs[id(m1)].custom_styles['node'][m1.state], 'active')
self.assertEqual(m.model_graphs[id(m2)].custom_styles['node'][m1.state], '')
# backwards compatibility test
dot1, _, _ = self.parse_dot(m1.get_graph())
dot, _, _ = self.parse_dot(m.get_graph())
self.assertEqual(dot, dot1)
def test_model_method_collision(self):
class GraphModel:
def get_graph(self):
return "This method already exists"
model = GraphModel()
with self.assertRaises(AttributeError):
m = self.machine_cls(model=model)
self.assertEqual(model.get_graph(), "This method already exists")
def test_to_method_filtering(self):
m = self.machine_cls(states=['A', 'B', 'C'], initial='A', use_pygraphviz=self.use_pygraphviz)
m.add_transition('to_state_A', 'B', 'A')
m.add_transition('to_end', '*', 'C')
_, _, edges = self.parse_dot(m.get_graph())
self.assertEqual(len([e for e in edges if e == '[label=to_state_A]']), 1)
self.assertEqual(len([e for e in edges if e == '[label=to_end]']), 3)
m2 = self.machine_cls(states=['A', 'B', 'C'], initial='A', show_auto_transitions=True,
use_pygraphviz=self.use_pygraphviz)
_, _, edges = self.parse_dot(m2.get_graph())
self.assertEqual(len(edges), 9)
self.assertEqual(len([e for e in edges if e == '[label=to_A]']), 3)
self.assertEqual(len([e for e in edges if e == '[label=to_C]']), 3)
def test_loops(self):
m = self.machine_cls(states=['A'], initial='A', use_pygraphviz=self.use_pygraphviz)
m.add_transition('reflexive', 'A', '=')
m.add_transition('fixed', 'A', None)
g1 = m.get_graph()
if self.use_pygraphviz:
dot_string = g1.string()
else:
dot_string = g1.source
try:
self.assertRegex(dot_string, r'A\s+->\s*A\s+\[label="(fixed|reflexive)')
except AttributeError: # Python 2 backwards compatibility
self.assertRegexpMatches(dot_string, r'A\s+->\s*A\s+\[label="(fixed|reflexive)')
def test_roi(self):
m = self.machine_cls(states=['A', 'B', 'C', 'D', 'E', 'F'], initial='A', use_pygraphviz=self.use_pygraphviz)
m.add_transition('to_state_A', 'B', 'A')
m.add_transition('to_state_C', 'B', 'C')
m.add_transition('to_state_F', 'B', 'F')
g1 = m.get_graph(show_roi=True)
dot, nodes, edges = self.parse_dot(g1)
self.assertEqual(len(edges), 0)
self.assertIn("label=A", dot)
# make sure that generating a graph without ROI has not influence on the later generated graph
# this has to be checked since graph.custom_style is a class property and is persistent for multiple
# calls of graph.generate()
m.to_C()
m.to_E()
_ = m.get_graph()
g2 = m.get_graph(show_roi=True)
dot, _, _ = self.parse_dot(g2)
self.assertNotIn("label=A", dot)
m.to_B()
g3 = m.get_graph(show_roi=True)
_, nodes, edges = self.parse_dot(g3)
self.assertEqual(len(edges), 3)
self.assertEqual(len(nodes), 4)
def test_state_tags(self):
@add_state_features(Tags, Timeout)
class CustomMachine(self.machine_cls):
pass
self.states[0] = {'name': 'A', 'tags': ['new', 'polling'], 'timeout': 5, 'on_enter': 'say_hello',
'on_exit': 'say_goodbye', 'on_timeout': 'do_something'}
m = CustomMachine(states=self.states, transitions=self.transitions, initial='A', show_state_attributes=True,
use_pygraphviz=self.use_pygraphviz)
g = m.get_graph(show_roi=True)
def test_label_attribute(self):
class LabelState(self.machine_cls.state_cls):
def __init__(self, *args, **kwargs):
self.label = kwargs.pop('label')
super(LabelState, self).__init__(*args, **kwargs)
class CustomMachine(self.machine_cls):
state_cls = LabelState
m = CustomMachine(states=[{'name': 'A', 'label': 'LabelA'},
{'name': 'B', 'label': 'NotLabelA'}],
transitions=[{'trigger': 'event', 'source': 'A', 'dest': 'B', 'label': 'LabelEvent'}],
initial='A', use_pygraphviz=self.use_pygraphviz)
dot, _, _ = self.parse_dot(m.get_graph())
self.assertIn("label=LabelA", dot)
self.assertIn("label=NotLabelA", dot)
self.assertIn("label=LabelEvent", dot)
self.assertNotIn("label=A", dot)
self.assertNotIn("label=event", dot)
def test_binary_stream(self):
from io import BytesIO
m = self.machine_cls(states=['A', 'B', 'C'], initial='A', auto_transitions=True,
title='A test', show_conditions=True, use_pygraphviz=self.use_pygraphviz)
b1 = BytesIO()
g = m.get_graph()
g.draw(b1, format='png', prog='dot')
b2 = g.draw(None, format='png', prog='dot')
self.assertEqual(b2, b1.getvalue())
b1.close()
@skipIf(pgv is None, 'Graph diagram test requires graphviz')
class TestDiagramsLocked(TestDiagrams):
machine_cls = MachineFactory.get_predefined(graph=True, locked=True)
@skipIf(pgv is None, 'NestedGraph diagram test requires graphviz')
class TestDiagramsNested(TestDiagrams):
machine_cls = MachineFactory.get_predefined(graph=True, nested=True)
def setUp(self):
super(TestDiagramsNested, self).setUp()
self.states = ['A', 'B',
{'name': 'C', 'children': [{'name': '1', 'children': ['a', 'b', 'c']},
'2', '3']}, 'D']
self.transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'}, # 1 edge
{'trigger': 'run', 'source': 'B', 'dest': 'C'}, # + 1 edge
{'trigger': 'sprint', 'source': 'C', 'dest': 'D', # + 1 edge
'conditions': 'is_fast'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'B'}, # + 1 edge
{'trigger': 'reset', 'source': '*', 'dest': 'A'}] # + 4 edges (from base state) = 8
def test_diagram(self):
m = self.machine_cls(states=self.states, transitions=self.transitions, initial='A', auto_transitions=False,
title='A test', show_conditions=True, use_pygraphviz=self.use_pygraphviz)
graph = m.get_graph()
self.assertIsNotNone(graph)
self.assertTrue("digraph" in str(graph))
_, nodes, edges = self.parse_dot(graph)
self.assertEqual(len(edges), 8)
# Test that graph properties match the Machine
self.assertEqual(set(m.states.keys()) - set(['C', 'C%s1' % NestedState.separator]),
set(nodes) - set(['C_anchor', 'C%s1_anchor' % NestedState.separator]))
m.walk()
m.run()
# write diagram to temp file
target = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
m.get_graph().draw(target.name, prog='dot')
self.assertTrue(os.path.getsize(target.name) > 0)
# backwards compatibility check
m.get_graph().draw(target.name, prog='dot')
self.assertTrue(os.path.getsize(target.name) > 0)
# cleanup temp file
target.close()
os.unlink(target.name)
def test_roi(self):
class Model:
def is_fast(self, *args, **kwargs):
return True
model = Model()
m = self.machine_cls(model, states=self.states, transitions=self.transitions, initial='A', title='A test',
use_pygraphviz=self.use_pygraphviz, show_conditions=True)
model.walk()
model.run()
g1 = model.get_graph(show_roi=True)
_, nodes, edges = self.parse_dot(g1)
self.assertEqual(len(edges), 4)
self.assertEqual(len(nodes), 4)
model.sprint()
g2 = model.get_graph(show_roi=True)
dot, nodes, edges = self.parse_dot(g2)
self.assertEqual(len(edges), 2)
self.assertEqual(len(nodes), 3)
def test_internal(self):
states = ['A', 'B']
transitions = [['go', 'A', 'B'],
dict(trigger='fail', source='A', dest=None, conditions=['failed']),
dict(trigger='fail', source='A', dest='B', unless=['failed'])]
m = self.machine_cls(states=states, transitions=transitions, initial='A', show_conditions=True,
use_pygraphviz=self.use_pygraphviz)
_, nodes, edges = self.parse_dot(m.get_graph())
self.assertEqual(len(nodes), 2)
self.assertEqual(len([e for e in edges if '[internal]' in e]), 1)
def test_internal_wildcards(self):
internal_only_once = r'^(?:(?!\[internal\]).)*\[internal\](?!.*\[internal\]).*$'
states = [
"initial",
"ready",
"running"
]
transitions = [
["booted", "initial", "ready"],
{"trigger": "polled", "source": "ready", "dest": "running", "conditions": "door_closed"},
["done", "running", "ready"],
["polled", "*", None]
]
m = self.machine_cls(states=states, transitions=transitions, show_conditions=True,
use_pygraphviz=self.use_pygraphviz, initial='initial')
_, nodes, edges = self.parse_dot(m.get_graph())
self.assertEqual(len(nodes), 3)
self.assertEqual(len([e for e in edges if re.match(internal_only_once, e)]), 3)
def test_nested_notebook(self):
states = [{'name': 'caffeinated',
'on_enter': 'do_x',
'children': ['dithering', 'running'],
'transitions': [['walk', 'dithering', 'running'],
['drink', 'dithering', '=']],
},
{'name': 'standing', 'on_enter': ['do_x', 'do_y'], 'on_exit': 'do_z'},
{'name': 'walking', 'tags': ['accepted', 'pending'], 'timeout': 5, 'on_timeout': 'do_z'}]
transitions = [
['walk', 'standing', 'walking'],
['go', 'standing', 'walking'],
['stop', 'walking', 'standing'],
{'trigger': 'drink', 'source': '*',
'dest': 'caffeinated{0}dithering'.format(self.machine_cls.state_cls.separator),
'conditions': 'is_hot', 'unless': 'is_too_hot'},
['relax', 'caffeinated', 'standing'],
['sip', 'standing', 'caffeinated']
]
@add_state_features(Timeout, Tags)
class CustomStateMachine(self.machine_cls):
def is_hot(self):
return True
def is_too_hot(self):
return False
def do_x(self):
pass
def do_z(self):
pass
extra_args = dict(auto_transitions=False, initial='standing', title='Mood Matrix',
show_conditions=True, show_state_attributes=True, use_pygraphviz=self.use_pygraphviz)
machine = CustomStateMachine(states=states, transitions=transitions, **extra_args)
g1 = machine.get_graph()
# dithering should have 4 'drink' edges, a) from walking, b) from initial, c) from running and d) from itself
if self.use_pygraphviz:
dot_string = g1.string()
else:
dot_string = g1.source
count = re.findall('-> "?caffeinated{0}dithering"?'.format(machine.state_cls.separator), dot_string)
self.assertEqual(4, len(count))
self.assertTrue(True)
machine.drink()
machine.drink()
g1 = machine.get_graph()
self.assertIsNotNone(g1)
@skipIf(pgv is None, 'NestedGraph diagram test requires graphviz')
class TestDiagramsLockedNested(TestDiagramsNested):
def setUp(self):
super(TestDiagramsLockedNested, self).setUp()
self.machine_cls = MachineFactory.get_predefined(graph=True, nested=True, locked=True)
transitions-0.8.10+3/tests/test_nesting.py 0000644 0002322 0002322 00000100235 14155650047 021113 0 ustar debalance debalance # -*- coding: utf-8 -*-
try:
from builtins import object
except ImportError:
pass
import sys
import tempfile
from os.path import getsize
from os import unlink
from transitions.extensions.nesting import NestedState
from transitions.extensions import MachineFactory
from unittest import skipIf
from .test_core import TestTransitions, TestCase
from .utils import Stuff, DummyModel
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
try:
# Just to skip tests if graphviz not installed
import graphviz as pgv # @UnresolvedImport
except ImportError: # pragma: no cover
pgv = None
default_separator = NestedState.separator
class Dummy(object):
pass
test_states = ['A', 'B',
{'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F']
class TestNestedTransitions(TestTransitions):
def setUp(self):
self.states = test_states
self.machine_cls = MachineFactory.get_predefined(nested=True)
self.state_cls = NestedState
self.stuff = Stuff(self.states, self.machine_cls)
def test_add_model(self):
model = Dummy()
self.stuff.machine.add_model(model, initial='E')
def test_init_machine_with_hella_arguments(self):
states = [
self.state_cls('State1'),
'State2',
{
'name': 'State3',
'on_enter': 'hello_world'
}
]
transitions = [
{'trigger': 'advance',
'source': 'State2',
'dest': 'State3'
}
]
s = Stuff()
self.stuff.machine_cls(
model=s, states=states, transitions=transitions, initial='State2')
s.advance()
self.assertEqual(s.message, 'Hello World!')
def test_init_machine_with_nested_states(self):
State = self.state_cls
a = State('A')
b = State('B')
b_1 = State('1')
b_2 = State('2')
b.add_substate(b_1)
b.add_substates([b_2])
m = self.stuff.machine_cls(states=[a, b])
self.assertEqual(m.states['B'].states['1'], b_1)
m.to("B{0}1".format(State.separator))
self.assertEqual(m.state, "B{0}1".format(State.separator))
def test_property_initial(self):
# Define with list of dictionaries
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D']
# Define with list of dictionaries
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
self.assertEqual(m.initial, 'A')
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='C')
self.assertEqual(m.initial, 'C')
m = self.stuff.machine_cls(states=states, transitions=transitions)
self.assertEqual(m.initial, 'initial')
def test_transition_definitions(self):
State = self.state_cls
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D']
# Define with list of dictionaries
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'},
{'trigger': 'run', 'source': 'C', 'dest': 'C%s1' % State.separator}
]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
m.walk()
self.assertEqual(m.state, 'B')
m.run()
self.assertEqual(m.state, 'C')
m.run()
self.assertEqual(m.state, 'C%s1' % State.separator)
# Define with list of lists
transitions = [
['walk', 'A', 'B'],
['run', 'B', 'C'],
['sprint', 'C', 'D']
]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
m.to_C()
m.sprint()
self.assertEqual(m.state, 'D')
def test_nested_definitions(self):
separator = self.state_cls.separator
state = {
'name': 'B',
'children': ['1', '2'],
'transitions': [['jo', '1', '2']],
'initial': '2'
}
m = self.stuff.machine_cls(initial='A', states=['A', state],
transitions=[['go', 'A', 'B'], ['go', 'B{0}2'.format(separator),
'B{0}1'.format(separator)]])
self.assertTrue(m.is_A())
m.go()
self.assertEqual(m.state, 'B{0}2'.format(separator))
m.go()
self.assertEqual(m.state, 'B{0}1'.format(separator))
m.jo()
def test_transitioning(self):
s = self.stuff
s.machine.add_transition('advance', 'A', 'B')
s.machine.add_transition('advance', 'B', 'C')
s.machine.add_transition('advance', 'C', 'D')
s.machine.add_transition('reset', '*', 'A')
self.assertEqual(len(s.machine.events['reset'].transitions), 6)
self.assertEqual(len(s.machine.events['reset'].transitions['C']), 1)
s.advance()
self.assertEqual(s.state, 'B')
self.assertFalse(s.is_A())
self.assertTrue(s.is_B())
s.advance()
self.assertEqual(s.state, 'C')
def test_conditions(self):
s = self.stuff
s.machine.add_transition('advance', 'A', 'B', conditions='this_passes')
s.machine.add_transition('advance', 'B', 'C', unless=['this_fails'])
s.machine.add_transition('advance', 'C', 'D', unless=['this_fails',
'this_passes'])
s.advance()
self.assertEqual(s.state, 'B')
s.advance()
self.assertEqual(s.state, 'C')
s.advance()
self.assertEqual(s.state, 'C')
def test_multiple_add_transitions_from_state(self):
State = self.state_cls
s = self.stuff
s.machine.add_transition(
'advance', 'A', 'B', conditions=['this_fails'])
s.machine.add_transition('advance', 'A', 'C')
s.machine.add_transition('advance', 'C', 'C%s2' % State.separator)
s.advance()
self.assertEqual(s.state, 'C')
s.advance()
self.assertEqual(s.state, 'C%s2' % State.separator)
self.assertFalse(s.is_C())
self.assertTrue(s.is_C(allow_substates=True))
def test_use_machine_as_model(self):
states = ['A', 'B', 'C', 'D']
m = self.stuff.machine_cls(states=states, initial='A')
m.add_transition('move', 'A', 'B')
m.add_transition('move_to_C', 'B', 'C')
m.move()
self.assertEqual(m.state, 'B')
def test_add_custom_state(self):
State = self.state_cls
s = self.stuff
s.machine.add_states([{'name': 'E', 'children': ['1', '2']}])
s.machine.add_state('E%s3' % State.separator)
s.machine.add_transition('go', '*', 'E%s1' % State.separator)
s.machine.add_transition('walk', '*', 'E%s3' % State.separator)
s.machine.add_transition('run', 'E', 'C{0}3{0}a'.format(State.separator))
s.go()
self.assertEqual('E{0}1'.format(State.separator), s.state)
s.walk()
self.assertEqual('E{0}3'.format(State.separator), s.state)
s.run()
self.assertEqual('C{0}3{0}a'.format(State.separator), s.state)
def test_add_nested_state(self):
m = self.machine_cls(states=['A'], initial='A')
m.add_state('B{0}1{0}a'.format(self.state_cls.separator))
self.assertIn('B', m.states)
self.assertIn('1', m.states['B'].states)
self.assertIn('a', m.states['B'].states['1'].states)
with self.assertRaises(ValueError):
m.add_state(m.states['A'])
def test_enter_exit_nested_state(self):
State = self.state_cls
mock = MagicMock()
def callback():
mock()
states = ['A', 'B', {'name': 'C', 'on_enter': callback, 'on_exit': callback,
'children': [{'name': '1', 'on_enter': callback, 'on_exit': callback}, '2', '3']},
{'name': 'D', 'on_enter': callback, 'on_exit': callback}]
transitions = [['go', 'A', 'C{0}1'.format(State.separator)],
['go', 'C', 'D']]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
m.go()
self.assertTrue(mock.called)
self.assertEqual(2, mock.call_count)
m.go()
self.assertTrue(m.is_D())
self.assertEqual(5, mock.call_count)
m.to_C()
self.assertEqual(7, mock.call_count)
m.to('C{0}1'.format(State.separator))
self.assertEqual(8, mock.call_count)
m.to('C{0}2'.format(State.separator))
self.assertEqual(9, mock.call_count)
def test_ordered_transitions(self):
State = self.state_cls
states = [{'name': 'first', 'children': ['second', 'third', {'name': 'fourth', 'children': ['fifth', 'sixth']},
'seventh']}, 'eighth', 'ninth']
m = self.stuff.machine_cls(states=states)
m.add_ordered_transitions()
self.assertEqual('initial', m.state)
m.next_state()
self.assertEqual('first', m.state)
m.next_state()
m.next_state()
self.assertEqual('first{0}third'.format(State.separator), m.state)
m.next_state()
m.next_state()
self.assertEqual('first{0}fourth{0}fifth'.format(State.separator), m.state)
m.next_state()
m.next_state()
self.assertEqual('first{0}seventh'.format(State.separator), m.state)
m.next_state()
m.next_state()
self.assertEqual('ninth', m.state)
# Include initial state in loop
m = self.stuff.machine_cls(states=states)
m.add_ordered_transitions(loop_includes_initial=False)
m.to_ninth()
m.next_state()
self.assertEqual(m.state, 'first')
# Test user-determined sequence and trigger name
m = self.stuff.machine_cls(states=states, initial='first')
m.add_ordered_transitions(['first', 'ninth'], trigger='advance')
m.advance()
self.assertEqual(m.state, 'ninth')
m.advance()
self.assertEqual(m.state, 'first')
# Via init argument
m = self.stuff.machine_cls(states=states, initial='first', ordered_transitions=True)
m.next_state()
self.assertEqual(m.state, 'first{0}second'.format(State.separator))
def test_pickle(self):
print("separator", self.state_cls.separator)
if sys.version_info < (3, 4):
import dill as pickle
else:
import pickle
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]},
'D', 'E', 'F']
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
m.walk()
dump = pickle.dumps(m)
self.assertIsNotNone(dump)
m2 = pickle.loads(dump)
self.assertEqual(m.state, m2.state)
m2.run()
m2.to_C_3_a()
m2.to_C_3_b()
def test_callbacks_duplicate(self):
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'C', 'before': 'before_change',
'after': 'after_change'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'}
]
m = self.stuff.machine_cls(states=['A', 'B', 'C'], transitions=transitions,
before_state_change='before_change',
after_state_change='after_change', send_event=True,
initial='A', auto_transitions=True)
m.before_change = MagicMock()
m.after_change = MagicMock()
m.walk()
self.assertEqual(m.before_change.call_count, 2)
self.assertEqual(m.after_change.call_count, 2)
def test_example_one(self):
State = self.state_cls
State.separator = '_'
states = ['standing', 'walking', {'name': 'caffeinated', 'children': ['dithering', 'running']}]
transitions = [['walk', 'standing', 'walking'],
['stop', 'walking', 'standing'],
['drink', 'caffeinated_dithering', '='],
['drink', 'caffeinated', 'caffeinated_dithering'],
['drink', '*', 'caffeinated'],
['walk', 'caffeinated', 'caffeinated_running'],
['relax', 'caffeinated', 'standing']]
machine = self.stuff.machine_cls(states=states, transitions=transitions, initial='standing',
ignore_invalid_triggers=True, name='Machine 1')
machine.walk() # Walking now
machine.stop() # let's stop for a moment
machine.drink() # coffee time
machine.state
self.assertEqual(machine.state, 'caffeinated')
machine.drink() # again!
self.assertEqual(machine.state, 'caffeinated_dithering')
machine.drink() # and again!
self.assertEqual(machine.state, 'caffeinated_dithering')
machine.walk() # we have to go faster
self.assertEqual(machine.state, 'caffeinated_running')
machine.stop() # can't stop moving!
machine.state
self.assertEqual(machine.state, 'caffeinated_running')
machine.relax() # leave nested state
machine.state # phew, what a ride
self.assertEqual(machine.state, 'standing')
machine.to_caffeinated_running() # auto transition fast track
machine.on_enter_caffeinated_running('callback_method')
def test_multiple_models(self):
class Model(object):
pass
s1, s2 = Model(), Model()
m = self.stuff.machine_cls(model=[s1, s2], states=['A', 'B', 'C'], initial='A')
self.assertEqual(len(m.models), 2)
m.add_transition('advance', 'A', 'B')
self.assertNotEqual(s1.advance, s2.advance)
s1.advance()
self.assertEqual(s1.state, 'B')
self.assertEqual(s2.state, 'A')
def test_excessive_nesting(self):
states = [{'name': 'A', 'children': []}]
curr = states[0]
for i in range(10):
curr['children'].append({'name': str(i), 'children': []})
curr = curr['children'][0]
m = self.stuff.machine_cls(states=states, initial='A')
def test_intial_state(self):
separator = self.state_cls.separator
states = [{'name': 'A', 'children': ['1', '2'], 'initial': '2'},
{'name': 'B', 'initial': '2',
'children': ['1', {'name': '2', 'initial': 'a',
'children': ['a', 'b']}]}]
transitions = [['do', 'A', 'B'],
['do', 'B{0}2'.format(separator),
'B{0}1'.format(separator)]]
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
self.assertEqual(m.state, 'A{0}2'.format(separator))
m.do()
self.assertEqual(m.state, 'B{0}2{0}a'.format(separator))
self.assertTrue(m.is_B(allow_substates=True))
m.do()
self.assertEqual(m.state, 'B{0}1'.format(separator))
m = self.stuff.machine_cls(states=states, transitions=transitions, initial='B{0}2{0}b'.format(separator))
self.assertTrue('B{0}2{0}b'.format(separator), m.state)
def test_get_triggers(self):
seperator = self.state_cls.separator
states = ['standing', 'walking', {'name': 'caffeinated', 'children': ['dithering', 'running']}]
transitions = [
['walk', 'standing', 'walking'],
['go', 'standing', 'walking'],
['stop', 'walking', 'standing'],
{'trigger': 'drink', 'source': '*', 'dest': 'caffeinated{0}dithering'.format(seperator),
'conditions': 'is_hot', 'unless': 'is_too_hot'},
['walk', 'caffeinated{0}dithering'.format(seperator), 'caffeinated{0}running'.format(seperator)],
['relax', 'caffeinated', 'standing']
]
machine = self.stuff.machine_cls(states=states, transitions=transitions, auto_transitions=False)
trans = machine.get_triggers('caffeinated{0}dithering'.format(seperator))
self.assertEqual(len(trans), 3)
self.assertTrue('relax' in trans)
def test_get_nested_transitions(self):
seperator = self.state_cls.separator
states = ['A', {'name': 'B', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b'],
'transitions': [['inner', 'a', 'b'],
['inner', 'b', 'a']]}],
'transitions': [['mid', '1', '1'],
['mid', '2', '3'],
['mid', '3', '1'],
['mid2', '2', '3'],
['mid_loop', '1', '1']]}]
transitions = [['outer', 'A', 'B'],
['outer', ['A', 'B'], 'C']]
machine = self.stuff.machine_cls(states=states, transitions=transitions, initial='A', auto_transitions=False)
self.assertEqual(10, len(machine.get_transitions()))
self.assertEqual(2, len(machine.get_transitions(source='A')))
self.assertEqual(2, len(machine.get_transitions('inner')))
self.assertEqual(3, len(machine.get_transitions('mid')))
self.assertEqual(3, len(machine.get_transitions(dest='B{0}1'.format(seperator))))
self.assertEqual(2, len(machine.get_transitions(source='B{0}2'.format(seperator),
dest='B{0}3'.format(seperator))))
self.assertEqual(1, len(machine.get_transitions(source='B{0}3{0}a'.format(seperator),
dest='B{0}3{0}b'.format(seperator))))
self.assertEqual(1, len(machine.get_transitions(source=machine.states['B'].states['3'].states['b'])))
# should be B_3_b -> B_3_a, B_3 -> B_1 and B -> C
self.assertEqual(3, len(machine.get_transitions(source=machine.states['B'].states['3'].states['b'],
delegate=True)))
def test_internal_transitions(self):
s = self.stuff
s.machine.add_transition('internal', 'A', None, prepare='increase_level')
s.internal()
self.assertEqual(s.state, 'A')
self.assertEqual(s.level, 2)
def test_transition_with_unknown_state(self):
s = self.stuff
with self.assertRaises(ValueError):
s.machine.add_transition('next', 'A', s.machine.state_cls('X'))
def test_skip_to_override(self):
mock = MagicMock()
class Model:
def to(self):
mock()
model1 = Model()
model2 = DummyModel()
machine = self.machine_cls([model1, model2], states=['A', 'B'], initial='A')
model1.to()
model2.to('B')
self.assertTrue(mock.called)
self.assertTrue(model2.is_B())
def test_trigger_parent(self):
parent_mock = MagicMock()
exit_mock = MagicMock()
enter_mock = MagicMock()
class Model:
def on_exit_A(self):
parent_mock()
def on_exit_A_1(self):
exit_mock()
def on_enter_A_2(self):
enter_mock()
model = Model()
machine = self.machine_cls(model, states=[{'name': 'A', 'children': ['1', '2']}],
transitions=[['go', 'A', 'A_2'], ['enter', 'A', 'A_1']], initial='A')
model.enter()
self.assertFalse(parent_mock.called)
model.go()
self.assertTrue(exit_mock.called)
self.assertTrue(enter_mock.called)
self.assertFalse(parent_mock.called)
def test_trigger_parent_model_self(self):
parent_mock = MagicMock()
exit_mock = MagicMock()
enter_mock = MagicMock()
class CustomMachine(self.machine_cls):
def on_exit_A(self):
parent_mock()
def on_exit_A_1(self):
exit_mock()
def on_enter_A_2(self):
enter_mock()
machine = CustomMachine(states=[{'name': 'A', 'children': ['1', '2']}],
transitions=[['go', 'A', 'A_2'], ['enter', 'A', 'A_1']], initial='A')
machine.enter()
self.assertFalse(parent_mock.called)
machine.go()
self.assertTrue(exit_mock.called)
self.assertTrue(enter_mock.called)
self.assertFalse(parent_mock.called)
def test_child_condition_persistence(self):
# even though the transition is invalid for the parent it is valid for the nested child state
# no invalid transition exception should be thrown
machine = self.machine_cls(states=[{'name': 'A', 'children': ['1', '2'], 'initial': '1',
'transitions': [{'trigger': 'go', 'source': '1', 'dest': '2',
'conditions': self.stuff.this_fails}]}, 'B'],
transitions=[['go', 'B', 'A']], initial='A')
self.assertFalse(False, machine.go())
def test_exception_in_state_enter_exit(self):
# https://github.com/pytransitions/transitions/issues/486
# NestedState._scope needs to be reset when an error is raised in a state callback
class Model:
def on_enter_B_1(self):
raise RuntimeError("Oh no!")
def on_exit_C_1(self):
raise RuntimeError("Oh no!")
states = ['A',
{'name': 'B', 'initial': '1', 'children': ['1', '2']},
{'name': 'C', 'initial': '1', 'children': ['1', '2']}]
model = Model()
machine = self.machine_cls(model, states=states, initial='A')
with self.assertRaises(RuntimeError):
model.to_B()
self.assertTrue(model.is_B_1())
machine.set_state('A', model)
with self.assertRaises(RuntimeError):
model.to_B()
with self.assertRaises(RuntimeError):
model.to_C()
model.to_A()
self.assertTrue(model.is_C_1())
machine.set_state('A', model)
model.to_C()
self.assertTrue(model.is_C_1())
def test_correct_subclassing(self):
from transitions.core import State
class WrongStateClass(self.machine_cls):
state_cls = State
class MyNestedState(NestedState):
pass
class CorrectStateClass(self.machine_cls):
state_cls = MyNestedState
with self.assertRaises(AssertionError):
m = WrongStateClass()
m = CorrectStateClass()
def test_queued_callbacks(self):
states = [
"initial",
{'name': 'A', 'children': [{'name': '1', 'on_enter': 'go'}, '2'],
'transitions': [['go', '1', '2']], 'initial': '1'}
]
machine = self.machine_cls(states=states, initial='initial', queued=True)
machine.to_A()
self.assertEqual("A{0}2".format(self.state_cls.separator), machine.state)
def test_nested_transitions(self):
states = [{
'name': 'A',
'states': [
{'name': 'B',
'states': [
{'name': 'C',
'states': ['1', '2'],
'initial': '1'}],
'transitions': [['go', 'C_1', 'C_2']],
'initial': 'C',
}],
'initial': 'B'
}]
machine = self.machine_cls(states=states, initial='A')
machine.go()
def test_auto_transitions_from_nested_callback(self):
def fail():
self.fail("C should not be exited!")
states = [
{'name': 'b', 'children': [
{'name': 'c', 'on_exit': fail, 'on_enter': 'to_b_c_ca', 'children': ['ca', 'cb']},
'd'
]},
]
machine = self.machine_cls(states=states, queued=True, initial='b')
machine.to_b_c()
class TestSeparatorsBase(TestCase):
separator = default_separator
def setUp(self):
class CustomNestedState(NestedState):
separator = self.separator
class CustomHierarchicalMachine(MachineFactory.get_predefined(nested=True)):
state_cls = CustomNestedState
self.states = test_states
self.machine_cls = CustomHierarchicalMachine
self.state_cls = CustomNestedState
self.stuff = Stuff(self.states, self.machine_cls)
def test_enter_exit_nested(self):
separator = self.state_cls.separator
s = self.stuff
s.machine.add_transition('advance', 'A', 'C{0}3'.format(separator))
s.machine.add_transition('reverse', 'C', 'A')
s.machine.add_transition('lower', ['C{0}1'.format(separator),
'C{0}3'.format(separator)], 'C{0}3{0}a'.format(separator))
s.machine.add_transition('rise', 'C{0}3'.format(separator), 'C{0}1'.format(separator))
s.machine.add_transition('fast', 'A', 'C{0}3{0}a'.format(separator))
for state_name in s.machine.get_nested_state_names():
state = s.machine.get_state(state_name)
state.on_enter.append('increase_level')
state.on_exit.append('decrease_level')
s.advance()
self.assertEqual('C{0}3'.format(separator), s.state)
self.assertEqual(2, s.level)
self.assertEqual(3, s.transitions) # exit A; enter C,3
s.lower()
self.assertEqual(s.state, 'C{0}3{0}a'.format(separator))
self.assertEqual(3, s.level)
self.assertEqual(4, s.transitions) # enter a
s.rise()
self.assertEqual('C%s1' % separator, s.state)
self.assertEqual(2, s.level)
self.assertEqual(7, s.transitions) # exit a, 3; enter 1
s.reverse()
self.assertEqual('A', s.state)
self.assertEqual(1, s.level)
self.assertEqual(10, s.transitions) # exit 1, C; enter A
s.fast()
self.assertEqual(s.state, 'C{0}3{0}a'.format(separator))
self.assertEqual(s.level, 3)
self.assertEqual(s.transitions, 14) # exit A; enter C, 3, a
s.to_A()
self.assertEqual(s.state, 'A')
self.assertEqual(s.level, 1)
self.assertEqual(s.transitions, 18) # exit a, 3, C; enter A
s.to_A()
self.assertEqual(s.state, 'A')
self.assertEqual(s.level, 1)
self.assertEqual(s.transitions, 20) # exit A; enter A
if separator == '_':
s.to_C_3_a()
else:
print("separator", separator)
s.to_C.s3.a()
self.assertEqual(s.state, 'C{0}3{0}a'.format(separator))
self.assertEqual(s.level, 3)
self.assertEqual(s.transitions, 24) # exit A; enter C, 3, a
def test_state_change_listeners(self):
State = self.state_cls
s = self.stuff
s.machine.add_transition('advance', 'A', 'C%s1' % State.separator)
s.machine.add_transition('reverse', 'C', 'A')
s.machine.add_transition('lower', 'C%s1' % State.separator, 'C{0}3{0}a'.format(State.separator))
s.machine.add_transition('rise', 'C%s3' % State.separator, 'C%s1' % State.separator)
s.machine.add_transition('fast', 'A', 'C{0}3{0}a'.format(State.separator))
s.machine.on_enter_C('hello_world')
s.machine.on_exit_C('goodbye')
s.machine.on_enter('C{0}3{0}a'.format(State.separator), 'greet')
s.machine.on_exit('C%s3' % State.separator, 'meet')
s.advance()
self.assertEqual(s.state, 'C%s1' % State.separator)
self.assertEqual(s.message, 'Hello World!')
s.lower()
self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator))
self.assertEqual(s.message, 'Hi')
s.rise()
self.assertEqual(s.state, 'C%s1' % State.separator)
self.assertTrue(s.message.startswith('Nice to'))
s.reverse()
self.assertEqual(s.state, 'A')
self.assertTrue(s.message.startswith('So long'))
s.fast()
self.assertEqual(s.state, 'C{0}3{0}a'.format(State.separator))
self.assertEqual(s.message, 'Hi')
s.to_A()
self.assertEqual(s.state, 'A')
self.assertTrue(s.message.startswith('So long'))
def test_nested_auto_transitions(self):
State = self.state_cls
s = self.stuff
s.to_C()
self.assertEqual(s.state, 'C')
state = 'C{0}3{0}a'.format(State.separator)
s.to(state)
self.assertEqual(s.state, state)
# backwards compatibility check (can be removed in 0.7)
self.assertEqual(s.state, state)
for state_name in s.machine.get_nested_state_names():
event_name = 'to_{0}'.format(state_name)
num_base_states = len(s.machine.states)
self.assertTrue(event_name in s.machine.events)
self.assertEqual(len(s.machine.events[event_name].transitions), num_base_states)
@skipIf(pgv is None, 'NestedGraph diagram test requires graphviz')
def test_ordered_with_graph(self):
GraphMachine = MachineFactory.get_predefined(graph=True, nested=True)
class CustomHierarchicalGraphMachine(GraphMachine):
state_cls = self.state_cls
states = ['A', 'B', {'name': 'C', 'children': ['1', '2',
{'name': '3', 'children': ['a', 'b', 'c']}]}, 'D', 'E', 'F']
machine = CustomHierarchicalGraphMachine(states=states, initial='A', auto_transitions=False,
ignore_invalid_triggers=True, use_pygraphviz=False)
machine.add_ordered_transitions(trigger='next_state')
machine.next_state()
self.assertEqual(machine.state, 'B')
target = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
machine.get_graph().draw(target.name, prog='dot')
self.assertTrue(getsize(target.name) > 0)
target.close()
unlink(target.name)
def test_example_two(self):
separator = self.state_cls.separator
states = ['A', 'B',
{'name': 'C', 'children': ['1', '2',
{'name': '3', 'children': ['a', 'b', 'c']}]
}]
transitions = [
['reset', 'C', 'A'],
['reset', 'C%s2' % separator, 'C'] # overwriting parent reset
]
# we rely on auto transitions
machine = self.stuff.machine_cls(states=states, transitions=transitions, initial='A')
machine.to_B() # exit state A, enter state B
machine.to_C() # exit B, enter C
if separator == '_':
machine.to_C_3_a()
self.assertTrue(machine.is_C(allow_substates=True))
self.assertFalse(machine.is_C())
self.assertTrue(machine.is_C_3(allow_substates=True))
self.assertFalse(machine.is_C_3())
self.assertTrue(machine.is_C_3_a())
else:
machine.to_C.s3.a() # enter C↦a; enter C↦3↦a;
self.assertTrue(machine.is_C(allow_substates=True))
self.assertFalse(machine.is_C())
self.assertTrue(machine.is_C.s3(allow_substates=True))
self.assertFalse(machine.is_C.s3())
self.assertTrue(machine.is_C.s3.a())
self.assertEqual(machine.state, 'C{0}3{0}a'.format(separator))
machine.to('C{0}2'.format(separator)) # exit C↦3↦a, exit C↦3, enter C↦2
self.assertEqual(machine.state, 'C{0}2'.format(separator))
machine.reset() # exit C↦2; reset C has been overwritten by C↦3
self.assertEqual('C', machine.state)
machine.reset() # exit C, enter A
self.assertEqual('A', machine.state)
class TestSeparatorsSlash(TestSeparatorsBase):
separator = '/'
class TestSeparatorsDot(TestSeparatorsBase):
separator = '.'
@skipIf(sys.version_info[0] < 3, "Unicode separators are only supported for Python 3")
class TestSeparatorUnicode(TestSeparatorsBase):
separator = u'↦'
transitions-0.8.10+3/tests/test_parallel.py 0000644 0002322 0002322 00000020523 14155650047 021241 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from collections import OrderedDict
from transitions.extensions.nesting import NestedState as State, _build_state_list
from transitions.extensions import HierarchicalGraphMachine
from transitions import MachineError
from .test_nesting import TestNestedTransitions as TestNested
from .test_pygraphviz import pgv
from .test_graphviz import pgv as gv
from unittest import skipIf
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
class TestParallel(TestNested):
def setUp(self):
super(TestParallel, self).setUp()
self.states = ['A', 'B', {'name': 'C',
'parallel': [{'name': '1', 'children': ['a', 'b'],
'initial': 'a',
'transitions': [['go', 'a', 'b']]},
{'name': '2', 'children': ['a', 'b'],
'initial': 'a',
'transitions': [['go', 'a', 'b']]}]}]
self.transitions = [['reset', 'C', 'A']]
def test_init(self):
m = self.stuff.machine_cls(states=self.states)
m.to_C()
self.assertEqual(['C{0}1{0}a'.format(State.separator), 'C{0}2{0}a'.format(State.separator)], m.state)
def test_enter(self):
m = self.stuff.machine_cls(states=self.states, transitions=self.transitions, initial='A')
m.to_C()
m.go()
self.assertEqual(['C{0}1{0}b'.format(State.separator), 'C{0}2{0}b'.format(State.separator)], m.state)
def test_exit(self):
class Model:
def __init__(self):
self.mock = MagicMock()
def on_exit_C(self):
self.mock()
def on_exit_C_1(self):
self.mock()
def on_exit_C_2(self):
self.mock()
model1 = Model()
m = self.stuff.machine_cls(model1, states=self.states, transitions=self.transitions, initial='A')
m.add_transition('reinit', 'C', 'C')
model1.to_C()
self.assertEqual(['C{0}1{0}a'.format(State.separator), 'C{0}2{0}a'.format(State.separator)], model1.state)
model1.reset()
self.assertTrue(model1.is_A())
self.assertEqual(3, model1.mock.call_count)
model2 = Model()
m.add_model(model2, initial='C')
model2.reinit()
self.assertEqual(['C{0}1{0}a'.format(State.separator), 'C{0}2{0}a'.format(State.separator)], model2.state)
self.assertEqual(3, model2.mock.call_count)
model2.reset()
self.assertTrue(model2.is_A())
self.assertEqual(6, model2.mock.call_count)
for mod in m.models:
mod.trigger('to_C')
for mod in m.models:
mod.trigger('reset')
self.assertEqual(6, model1.mock.call_count)
self.assertEqual(9, model2.mock.call_count)
def test_parent_transition(self):
m = self.stuff.machine_cls(states=self.states)
m.add_transition('switch', 'C{0}2{0}a'.format(State.separator), 'C{0}2{0}b'.format(State.separator))
m.to_C()
m.switch()
self.assertEqual(['C{0}1{0}a'.format(State.separator), 'C{0}2{0}b'.format(State.separator)], m.state)
def test_shallow_parallel(self):
sep = self.state_cls.separator
states = [
{
'name': 'P', 'parallel':
[
'1', # no initial state
{'name': '2', 'children': ['a', 'b'], 'initial': 'b'}
]
},
'X'
]
m = self.machine_cls(states=states, initial='P')
self.assertEqual(['P{0}1'.format(sep), 'P{0}2{0}b'.format(sep)], m.state)
m.to_X()
self.assertEqual('X', m.state)
m.to_P()
self.assertEqual(['P{0}1'.format(sep), 'P{0}2{0}b'.format(sep)], m.state)
with self.assertRaises(MachineError):
m.to('X')
def test_multiple(self):
states = ['A',
{'name': 'B',
'parallel': [
{'name': '1', 'parallel': [
{'name': 'a', 'children': ['x', 'y', 'z'], 'initial': 'z'},
{'name': 'b', 'children': ['x', 'y', 'z'], 'initial': 'y'}
]},
{'name': '2', 'children': ['a', 'b', 'c'], 'initial': 'a'},
]}]
m = self.stuff.machine_cls(states=states, initial='A')
self.assertTrue(m.is_A())
m.to_B()
self.assertEqual([['B{0}1{0}a{0}z'.format(State.separator),
'B{0}1{0}b{0}y'.format(State.separator)],
'B{0}2{0}a'.format(State.separator)], m.state)
# check whether we can initialize a new machine in a parallel state
m2 = self.machine_cls(states=states, initial=m.state)
self.assertEqual([['B{0}1{0}a{0}z'.format(State.separator),
'B{0}1{0}b{0}y'.format(State.separator)],
'B{0}2{0}a'.format(State.separator)], m2.state)
m.to_A()
self.assertEqual('A', m.state)
m2.to_A()
self.assertEqual(m.state, m2.state)
def test_deep_initial(self):
m = self.machine_cls(initial=['A', 'B{0}2{0}a'.format(State.separator)])
m.to_B()
self.assertEqual('B', m.state)
def test_parallel_initial(self):
m = self.machine_cls(states=['A', 'B', {'name': 'C', 'parallel': ['1', '2']}], initial='C')
m = self.machine_cls(states=['A', 'B', {'name': 'C', 'parallel': ['1', '2']}], initial=['C_1', 'C_2'])
def test_multiple_deeper(self):
sep = self.state_cls.separator
states = ['A',
{'name': 'P',
'parallel': [
'1',
{'name': '2', 'parallel': [
{'name': 'a'},
{'name': 'b', 'parallel': [
{'name': 'x', 'parallel': ['1', '2']}, 'y'
]}
]},
]}]
ref_state = ['P{0}1'.format(sep),
['P{0}2{0}a'.format(sep),
[['P{0}2{0}b{0}x{0}1'.format(sep),
'P{0}2{0}b{0}x{0}2'.format(sep)],
'P{0}2{0}b{0}y'.format(sep)]]]
m = self.stuff.machine_cls(states=states, initial='A')
self.assertTrue(m.is_A())
m.to_P()
self.assertEqual(ref_state, m.state)
m.to_A()
def test_model_state_conversion(self):
sep = self.state_cls.separator
states = ['P{0}1'.format(sep),
['P{0}2{0}a'.format(sep),
[['P{0}2{0}b{0}x{0}1'.format(sep),
'P{0}2{0}b{0}x{0}2'.format(sep)],
'P{0}2{0}b{0}y'.format(sep)]]]
tree = OrderedDict(
[('P', OrderedDict(
[('1', OrderedDict()),
('2', OrderedDict(
[('a', OrderedDict()),
('b', OrderedDict(
[('x', OrderedDict(
[('1', OrderedDict()),
('2', OrderedDict())])),
('y', OrderedDict())]
))]
))]
))]
)
m = self.machine_cls()
self.assertEqual(tree, m._build_state_tree(states, sep))
self.assertEqual(states, _build_state_list(tree, sep))
@skipIf(pgv is None, "pygraphviz is not available")
class TestParallelWithPyGraphviz(TestParallel):
def setUp(self):
class PGVMachine(HierarchicalGraphMachine):
def __init__(self, *args, **kwargs):
kwargs['use_pygraphviz'] = True
super(PGVMachine, self).__init__(*args, **kwargs)
super(TestParallelWithPyGraphviz, self).setUp()
self.machine_cls = PGVMachine
@skipIf(gv is None, "graphviz is not available")
class TestParallelWithGraphviz(TestParallel):
def setUp(self):
class GVMachine(HierarchicalGraphMachine):
def __init__(self, *args, **kwargs):
kwargs['use_pygraphviz'] = False
super(GVMachine, self).__init__(*args, **kwargs)
super(TestParallelWithGraphviz, self).setUp()
self.machine_cls = GVMachine
transitions-0.8.10+3/tests/test_enum.py 0000644 0002322 0002322 00000031222 14155650047 020407 0 ustar debalance debalance from unittest import TestCase, skipIf
try:
import enum
except ImportError:
enum = None
from transitions.extensions import MachineFactory
from .test_pygraphviz import pgv
from .test_graphviz import pgv as gv
@skipIf(enum is None, "enum is not available")
class TestEnumsAsStates(TestCase):
def setUp(self):
class States(enum.Enum):
RED = 1
YELLOW = 2
GREEN = 3
self.machine_cls = MachineFactory.get_predefined()
self.States = States
def test_pass_enums_as_states(self):
m = self.machine_cls(states=self.States, initial=self.States.YELLOW)
assert m.state == self.States.YELLOW
assert m.is_RED() is False
assert m.is_YELLOW() is True
assert m.is_RED() is False
m.to_RED()
assert m.state == self.States.RED
assert m.is_RED() is True
assert m.is_YELLOW() is False
assert m.is_GREEN() is False
def test_transitions(self):
m = self.machine_cls(states=self.States, initial=self.States.RED)
m.add_transition('switch_to_yellow', self.States.RED, self.States.YELLOW)
m.add_transition('switch_to_green', 'YELLOW', 'GREEN')
m.switch_to_yellow()
assert m.is_YELLOW() is True
m.switch_to_green()
assert m.is_YELLOW() is False
assert m.is_GREEN() is True
def test_if_enum_has_string_behavior(self):
class States(str, enum.Enum):
__metaclass__ = enum.EnumMeta
RED = 'red'
YELLOW = 'yellow'
m = self.machine_cls(states=States, auto_transitions=False, initial=States.RED)
m.add_transition('switch_to_yellow', States.RED, States.YELLOW)
m.switch_to_yellow()
assert m.is_YELLOW() is True
def test_property_initial(self):
transitions = [
{'trigger': 'switch_to_yellow', 'source': self.States.RED, 'dest': self.States.YELLOW},
{'trigger': 'switch_to_green', 'source': 'YELLOW', 'dest': 'GREEN'},
]
m = self.machine_cls(states=self.States, initial=self.States.RED, transitions=transitions)
m.switch_to_yellow()
assert m.is_YELLOW()
m.switch_to_green()
assert m.is_GREEN()
def test_pass_state_instances_instead_of_names(self):
state_A = self.machine_cls.state_cls(self.States.YELLOW)
state_B = self.machine_cls.state_cls(self.States.GREEN)
states = [state_A, state_B]
m = self.machine_cls(states=states, initial=state_A)
assert m.state == self.States.YELLOW
m.add_transition('advance', state_A, state_B)
m.advance()
assert m.state == self.States.GREEN
def test_state_change_listeners(self):
class States(enum.Enum):
ONE = 1
TWO = 2
class Stuff(object):
def __init__(self, machine_cls):
self.state = None
self.machine = machine_cls(states=States, initial=States.ONE, model=self)
self.machine.add_transition('advance', States.ONE, States.TWO)
self.machine.add_transition('reverse', States.TWO, States.ONE)
self.machine.on_enter_TWO('hello')
self.machine.on_exit_TWO('goodbye')
def hello(self):
self.message = 'Hello'
def goodbye(self):
self.message = 'Goodbye'
s = Stuff(self.machine_cls)
s.advance()
assert s.is_TWO()
assert s.message == 'Hello'
s.reverse()
assert s.is_ONE()
assert s.message == 'Goodbye'
def test_enum_zero(self):
from enum import IntEnum
class State(IntEnum):
FOO = 0
BAR = 1
transitions = [
['foo', State.FOO, State.BAR],
['bar', State.BAR, State.FOO]
]
m = self.machine_cls(states=State, initial=State.FOO, transitions=transitions)
m.foo()
self.assertTrue(m.is_BAR())
m.bar()
self.assertTrue(m.is_FOO())
def test_get_transitions(self):
m = self.machine_cls(states=self.States, initial=self.States.RED)
self.assertEqual(3, len(m.get_transitions(source=self.States.RED)))
self.assertEqual(3, len(m.get_transitions(dest=self.States.RED)))
self.assertEqual(1, len(m.get_transitions(source=self.States.RED, dest=self.States.YELLOW)))
self.assertEqual(9, len(m.get_transitions()))
m.add_transition('switch_to_yellow', self.States.RED, self.States.YELLOW)
self.assertEqual(4, len(m.get_transitions(source=self.States.RED)))
# we expect two return values. 'switch_to_yellow' and 'to_YELLOW'
self.assertEqual(2, len(m.get_transitions(source=self.States.RED, dest=self.States.YELLOW)))
def test_get_triggers(self):
m = self.machine_cls(states=self.States, initial=self.States.RED)
trigger_name = m.get_triggers(m.state.name)
trigger_enum = m.get_triggers(m.state)
self.assertEqual(trigger_enum, trigger_name)
@skipIf(enum is None, "enum is not available")
class TestNestedStateEnums(TestEnumsAsStates):
def setUp(self):
super(TestNestedStateEnums, self).setUp()
self.machine_cls = MachineFactory.get_predefined(nested=True)
def test_root_enums(self):
states = [self.States.RED, self.States.YELLOW,
{'name': self.States.GREEN, 'children': ['tick', 'tock'], 'initial': 'tick'}]
m = self.machine_cls(states=states, initial=self.States.GREEN)
self.assertTrue(m.is_GREEN(allow_substates=True))
self.assertTrue(m.is_GREEN_tick())
m.to_RED()
self.assertTrue(m.state is self.States.RED)
def test_nested_enums(self):
states = ['A', self.States.GREEN,
{'name': 'C', 'children': self.States, 'initial': self.States.GREEN}]
m1 = self.machine_cls(states=states, initial='C')
m2 = self.machine_cls(states=states, initial='A')
self.assertEqual(m1.state, self.States.GREEN)
self.assertTrue(m1.is_GREEN()) # even though it is actually C_GREEN
m2.to_GREEN()
self.assertTrue(m2.is_C_GREEN()) # even though it is actually just GREEN
self.assertEqual(m1.state, m2.state)
m1.to_A()
self.assertNotEqual(m1.state, m2.state)
def test_initial_enum(self):
m1 = self.machine_cls(states=self.States, initial=self.States.GREEN)
self.assertEqual(self.States.GREEN, m1.state)
self.assertEqual(m1.state.name, self.States.GREEN.name)
def test_duplicate_states(self):
with self.assertRaises(ValueError):
self.machine_cls(states=['A', 'A'])
def test_duplicate_states_from_enum_members(self):
class Foo(enum.Enum):
A = 1
with self.assertRaises(ValueError):
self.machine_cls(states=[Foo.A, Foo.A])
def test_add_enum_transition(self):
class Foo(enum.Enum):
A = 0
B = 1
class Bar(enum.Enum):
FOO = Foo
C = 2
m = self.machine_cls(states=Bar, initial=Bar.C, auto_transitions=False)
m.add_transition('go', Bar.C, Foo.A, conditions=lambda: False)
trans = m.events['go'].transitions['C']
self.assertEqual(1, len(trans))
self.assertEqual('FOO_A', trans[0].dest)
m.add_transition('go', Bar.C, 'FOO_B')
self.assertEqual(2, len(trans))
self.assertEqual('FOO_B', trans[1].dest)
m.go()
self.assertTrue(m.is_FOO_B())
m.add_transition('go', Foo.B, 'C')
trans = m.events['go'].transitions['FOO_B']
self.assertEqual(1, len(trans))
self.assertEqual('C', trans[0].dest)
m.go()
self.assertEqual(m.state, Bar.C)
def test_add_nested_enums_as_nested_state(self):
class Foo(enum.Enum):
A = 0
B = 1
class Bar(enum.Enum):
FOO = Foo
C = 2
m = self.machine_cls(states=Bar, initial=Bar.C)
self.assertEqual(sorted(m.states['FOO'].states.keys()), ['A', 'B'])
m.add_transition('go', 'FOO_A', 'C')
m.add_transition('go', 'C', 'FOO_B')
m.add_transition('foo', Bar.C, Bar.FOO)
m.to_FOO_A()
self.assertFalse(m.is_C())
self.assertTrue(m.is_FOO(allow_substates=True))
self.assertTrue(m.is_FOO_A())
self.assertTrue(m.is_FOO_A(allow_substates=True))
m.go()
self.assertEqual(Bar.C, m.state)
m.go()
self.assertEqual(Foo.B, m.state)
m.to_state(m, Bar.C.name)
self.assertEqual(Bar.C, m.state)
m.foo()
self.assertEqual(Bar.FOO, m.state)
def test_enum_model_conversion(self):
class Inner(enum.Enum):
I1 = 1
I2 = 2
I3 = 3
I4 = 0
class Middle(enum.Enum):
M1 = 10
M2 = 20
M3 = 30
M4 = Inner
class Outer(enum.Enum):
O1 = 100
O2 = 200
O3 = 300
O4 = Middle
m = self.machine_cls(states=Outer, initial=Outer.O1)
def test_enum_initial(self):
class Foo(enum.Enum):
A = 0
B = 1
class Bar(enum.Enum):
FOO = dict(children=Foo, initial=Foo.A)
C = 2
m = self.machine_cls(states=Bar, initial=Bar.FOO)
self.assertTrue(m.is_FOO_A())
def test_separator_naming_error(self):
class UnderscoreEnum(enum.Enum):
STATE_NAME = 0
# using _ in enum names in the default config should raise an error
with self.assertRaises(ValueError):
self.machine_cls(states=UnderscoreEnum)
# changing the separator should make it work
class DotNestedState(self.machine_cls.state_cls):
separator = '.'
# make custom machine use custom state with dot separator
class DotMachine(self.machine_cls):
state_cls = DotNestedState
m = DotMachine(states=UnderscoreEnum)
def test_get_nested_transitions(self):
class Errors(enum.Enum):
NONE = self.States
UNKNOWN = 2
POWER = 3
m = self.machine_cls(states=Errors, initial=Errors.NONE.value.RED, auto_transitions=False)
m.add_transition('error', Errors.NONE, Errors.UNKNOWN)
m.add_transition('outage', [Errors.NONE, Errors.UNKNOWN], Errors.POWER)
m.add_transition('reset', '*', self.States.RED)
m.add_transition('toggle', self.States.RED, self.States.GREEN)
m.add_transition('toggle', self.States.GREEN, self.States.YELLOW)
m.add_transition('toggle', self.States.YELLOW, self.States.RED)
self.assertEqual(5, len(m.get_transitions(dest=self.States.RED)))
self.assertEqual(1, len(m.get_transitions(source=self.States.RED, dest=self.States.RED, delegate=True)))
self.assertEqual(1, len(m.get_transitions(source=self.States.RED, dest=self.States.GREEN)))
self.assertEqual(1, len(m.get_transitions(dest=self.States.GREEN)))
self.assertEqual(3, len(m.get_transitions(trigger='toggle')))
def test_multiple_deeper(self):
class X(enum.Enum):
X1 = 1
X2 = 2
class B(enum.Enum):
B1 = dict(parallel=X)
B2 = 2
class A(enum.Enum):
A1 = dict(parallel=B)
A2 = 2
class Q(enum.Enum):
Q1 = 1
Q2 = dict(parallel=A)
class P(enum.Enum):
P1 = 1
P2 = dict(parallel=Q)
class States(enum.Enum):
S1 = 1
S2 = dict(parallel=P)
m = self.machine_cls(states=States, initial=States.S1)
self.assertEqual(m.state, States.S1)
m.to_S2()
ref_state = [P.P1, [Q.Q1, [[[X.X1, X.X2], B.B2], A.A2]]]
self.assertEqual(ref_state, m.state)
@skipIf(enum is None or (pgv is None and gv is None), "enum and (py)graphviz are not available")
class TestEnumWithGraph(TestEnumsAsStates):
def setUp(self):
super(TestEnumWithGraph, self).setUp()
self.machine_cls = MachineFactory.get_predefined(graph=True)
def test_get_graph(self):
m = self.machine_cls(states=self.States, initial=self.States.GREEN)
roi = m.get_graph(show_roi=False)
self.assertIsNotNone(roi)
def test_get_graph_show_roi(self):
m = self.machine_cls(states=self.States, initial=self.States.GREEN)
roi = m.get_graph(show_roi=True)
self.assertIsNotNone(roi)
@skipIf(enum is None or (pgv is None and gv is None), "enum and (py)graphviz are not available")
class TestNestedStateGraphEnums(TestNestedStateEnums):
def setUp(self):
super(TestNestedStateGraphEnums, self).setUp()
self.machine_cls = MachineFactory.get_predefined(nested=True, graph=True)
transitions-0.8.10+3/tests/test_reuse.py 0000644 0002322 0002322 00000030740 14155650047 020572 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from transitions import MachineError
from transitions.extensions import MachineFactory
from transitions.extensions.nesting import NestedState
from .utils import Stuff
from unittest import TestCase
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock
test_states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]},
'D', 'E', 'F']
class TestReuseSeparatorBase(TestCase):
separator = '_'
def setUp(self):
class CustomState(NestedState):
separator = self.separator
class CustomMachine(MachineFactory.get_predefined(nested=True)):
state_cls = CustomState
self.states = test_states
self.machine_cls = CustomMachine
self.state_cls = self.machine_cls.state_cls
self.stuff = Stuff(self.states, self.machine_cls)
def test_wrong_nesting(self):
correct = ['A', {'name': 'B', 'children': self.stuff.machine}]
wrong_type = ['A', {'name': 'B', 'children': self.stuff}]
siblings = ['A', {'name': 'B', 'children': ['1', self.stuff.machine]}]
collision = ['A', {'name': 'B', 'children': ['A', self.stuff.machine]}]
m = self.machine_cls(states=correct)
if m.state_cls.separator != '_':
m.to_B.C.s3.a()
else:
m.to_B_C_3_a()
with self.assertRaises(ValueError):
m = self.machine_cls(states=wrong_type)
with self.assertRaises(ValueError):
m = self.machine_cls(states=collision)
m = self.machine_cls(states=siblings)
if m.state_cls.separator != '_':
m.to_B.s1()
m.to_B.A()
else:
m.to_B_1()
m.to_B_A()
class TestReuseSeparatorDot(TestReuseSeparatorBase):
separator = '.'
class TestReuse(TestCase):
def setUp(self):
self.states = test_states
self.machine_cls = MachineFactory.get_predefined(nested=True)
self.state_cls = self.machine_cls.state_cls
self.stuff = Stuff(self.states, self.machine_cls)
def test_blueprint_reuse(self):
State = self.state_cls
states = ['1', '2', '3']
transitions = [
{'trigger': 'increase', 'source': '1', 'dest': '2'},
{'trigger': 'increase', 'source': '2', 'dest': '3'},
{'trigger': 'decrease', 'source': '3', 'dest': '2'},
{'trigger': 'decrease', 'source': '1', 'dest': '1'},
{'trigger': 'reset', 'source': '*', 'dest': '1'},
]
counter = self.machine_cls(states=states, transitions=transitions, before_state_change='check',
after_state_change='clear', initial='1')
new_states = ['A', 'B', {'name': 'C', 'children': counter}]
new_transitions = [
{'trigger': 'forward', 'source': 'A', 'dest': 'B'},
{'trigger': 'forward', 'source': 'B', 'dest': 'C%s1' % State.separator},
{'trigger': 'backward', 'source': 'C', 'dest': 'B'},
{'trigger': 'backward', 'source': 'B', 'dest': 'A'},
{'trigger': 'calc', 'source': '*', 'dest': 'C'},
]
walker = self.machine_cls(states=new_states, transitions=new_transitions, before_state_change='watch',
after_state_change='look_back', initial='A')
walker.watch = lambda: 'walk'
walker.look_back = lambda: 'look_back'
walker.check = lambda: 'check'
walker.clear = lambda: 'clear'
with self.assertRaises(MachineError):
walker.increase()
self.assertEqual(walker.state, 'A')
walker.forward()
walker.forward()
self.assertEqual(walker.state, 'C%s1' % State.separator)
walker.increase()
self.assertEqual(walker.state, 'C%s2' % State.separator)
walker.reset()
self.assertEqual(walker.state, 'C%s1' % State.separator)
walker.to_A()
self.assertEqual(walker.state, 'A')
walker.calc()
self.assertEqual(walker.state, 'C{0}1'.format(State.separator))
def test_blueprint_initial_false(self):
child = self.machine_cls(states=['A', 'B'], initial='A')
parent = self.machine_cls(states=['a', 'b', {'name': 'c', 'children': child, 'initial': False}])
parent.to_c()
self.assertEqual(parent.state, 'c')
def test_blueprint_remap(self):
State = self.state_cls
states = ['1', '2', '3', 'finished']
transitions = [
{'trigger': 'increase', 'source': '1', 'dest': '2'},
{'trigger': 'increase', 'source': '2', 'dest': '3'},
{'trigger': 'decrease', 'source': '3', 'dest': '2'},
{'trigger': 'decrease', 'source': '1', 'dest': '1'},
{'trigger': 'reset', 'source': '*', 'dest': '1'},
{'trigger': 'done', 'source': '3', 'dest': 'finished'}
]
counter = self.machine_cls(states=states, transitions=transitions, initial='1')
new_states = ['A', 'B', {'name': 'C', 'children':
[counter, {'name': 'X', 'children': ['will', 'be', 'filtered', 'out']}],
'remap': {'finished': 'A', 'X': 'A'}}]
new_transitions = [
{'trigger': 'forward', 'source': 'A', 'dest': 'B'},
{'trigger': 'forward', 'source': 'B', 'dest': 'C%s1' % State.separator},
{'trigger': 'backward', 'source': 'C', 'dest': 'B'},
{'trigger': 'backward', 'source': 'B', 'dest': 'A'},
{'trigger': 'calc', 'source': '*', 'dest': 'C%s1' % State.separator},
]
walker = self.machine_cls(states=new_states, transitions=new_transitions, before_state_change='watch',
after_state_change='look_back', initial='A')
walker.watch = lambda: 'walk'
walker.look_back = lambda: 'look_back'
counter.increase()
counter.increase()
counter.done()
self.assertEqual(counter.state, 'finished')
with self.assertRaises(MachineError):
walker.increase()
self.assertEqual(walker.state, 'A')
walker.forward()
walker.forward()
self.assertEqual(walker.state, 'C%s1' % State.separator)
walker.increase()
self.assertEqual(walker.state, 'C%s2' % State.separator)
walker.reset()
self.assertEqual(walker.state, 'C%s1' % State.separator)
walker.to_A()
self.assertEqual(walker.state, 'A')
walker.calc()
self.assertEqual(walker.state, 'C%s1' % State.separator)
walker.increase()
walker.increase()
walker.done()
self.assertEqual(walker.state, 'A')
self.assertFalse('C.finished' in walker.states)
def test_example_reuse(self):
State = self.state_cls
count_states = ['1', '2', '3', 'done']
count_trans = [
['increase', '1', '2'],
['increase', '2', '3'],
['decrease', '3', '2'],
['decrease', '2', '1'],
{'trigger': 'done', 'source': '3', 'dest': 'done', 'conditions': 'this_passes'},
]
counter = self.machine_cls(states=count_states, transitions=count_trans, initial='1')
counter.increase() # love my counter
states = ['waiting', 'collecting', {'name': 'counting', 'children': counter}]
states_remap = ['waiting', 'collecting', {'name': 'counting', 'children': counter, 'remap': {'done': 'waiting'}}]
transitions = [
['collect', '*', 'collecting'],
['wait', '*', 'waiting'],
['count', '*', 'counting%s1' % State.separator]
]
collector = self.stuff.machine_cls(states=states, transitions=transitions, initial='waiting')
collector.this_passes = self.stuff.this_passes
collector.collect() # collecting
collector.count() # let's see what we got
collector.increase() # counting_2
collector.increase() # counting_3
collector.done() # counting_done
self.assertEqual(collector.state, 'counting{0}done'.format(State.separator))
collector.wait() # go back to waiting
self.assertEqual(collector.state, 'waiting')
# reuse counter instance with remap
collector = self.machine_cls(states=states_remap, transitions=transitions, initial='waiting')
collector.this_passes = self.stuff.this_passes
collector.collect() # collecting
collector.count() # let's see what we got
collector.increase() # counting_2
collector.increase() # counting_3
collector.done() # counting_done
self.assertEqual(collector.state, 'waiting')
# # same as above but with states and therefore stateless embedding
states_remap[2]['children'] = count_states
transitions.append(['increase', 'counting%s1' % State.separator, 'counting%s2' % State.separator])
transitions.append(['increase', 'counting%s2' % State.separator, 'counting%s3' % State.separator])
transitions.append(['done', 'counting%s3' % State.separator, 'waiting'])
collector = self.machine_cls(states=states_remap, transitions=transitions, initial='waiting')
collector.collect() # collecting
collector.count() # let's see what we got
collector.increase() # counting_2
collector.increase() # counting_3
collector.done() # counting_done
self.assertEqual(collector.state, 'waiting')
# check if counting_done was correctly omitted
collector.add_transition('fail', '*', 'counting%sdone' % State.separator)
with self.assertRaises(ValueError):
collector.fail()
def test_reuse_prepare(self):
class Model:
def __init__(self):
self.prepared = False
def preparation(self):
self.prepared = True
ms_model = Model()
ms = self.machine_cls(ms_model, states=["C", "D"],
transitions={"trigger": "go", "source": "*", "dest": "D",
"prepare": "preparation"}, initial="C")
ms_model.go()
self.assertTrue(ms_model.prepared)
m_model = Model()
m = self.machine_cls(m_model, states=["A", "B", {"name": "NEST", "children": ms}])
m_model.to('NEST%sC' % self.state_cls.separator)
m_model.go()
self.assertTrue(m_model.prepared)
def test_reuse_self_reference(self):
separator = self.state_cls.separator
class Nested(self.machine_cls):
def __init__(self, parent):
self.parent = parent
self.mock = MagicMock()
states = ['1', '2']
transitions = [{'trigger': 'finish', 'source': '*', 'dest': '2', 'after': self.print_msg}]
super(Nested, self).__init__(states=states, transitions=transitions, initial='1')
def print_msg(self):
self.mock()
self.parent.print_top()
class Top(self.machine_cls):
def print_msg(self):
self.mock()
def __init__(self):
self.nested = Nested(self)
self.mock = MagicMock()
states = ['A', {'name': 'B', 'children': self.nested}]
transitions = [dict(trigger='print_top', source='*', dest='=', after=self.print_msg),
dict(trigger='to_nested', source='*', dest='B{0}1'.format(separator))]
super(Top, self).__init__(states=states, transitions=transitions, initial='A')
top_machine = Top()
self.assertEqual(top_machine, top_machine.nested.parent)
top_machine.to_nested()
top_machine.finish()
self.assertTrue(top_machine.mock.called)
self.assertTrue(top_machine.nested.mock.called)
self.assertIs(top_machine.nested.get_state('2').on_enter,
top_machine.get_state('B{0}2'.format(separator)).on_enter)
def test_reuse_machine_config(self):
simple_config = {
"name": "Child",
"states": ["1", "2"],
"transitions": [['go', '1', '2']],
"initial": "1"
}
simple_cls = MachineFactory.get_predefined()
simple = simple_cls(**simple_config)
self.assertTrue(simple.is_1())
self.assertTrue(simple.go())
self.assertTrue(simple.is_2())
machine = self.machine_cls(states=['A', simple_config], initial='A')
machine.to_Child()
machine.go()
self.assertTrue(machine.is_Child_2())
transitions-0.8.10+3/tests/test_add_remove.py 0000644 0002322 0002322 00000005201 14155650047 021546 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from transitions import Machine
from unittest import TestCase
import gc
import weakref
import threading
class Dummy(object):
pass
class TestTransitionsAddRemove(TestCase):
def test_garbage_collection(self):
states = ['A', 'B', 'C', 'D', 'E', 'F']
machine = Machine(model=[], states=states, initial='A', name='Test Machine')
machine.add_transition('advance', 'A', 'B')
machine.add_transition('advance', 'B', 'C')
machine.add_transition('advance', 'C', 'D')
s1 = Dummy()
s2 = Dummy()
s2_collected = threading.Event()
s2_proxy = weakref.proxy(s2, lambda _: s2_collected.set())
machine.add_model([s1, s2])
self.assertTrue(s1.is_A())
self.assertTrue(s2.is_A())
s1.advance()
self.assertTrue(s1.is_B())
self.assertTrue(s2.is_A())
self.assertFalse(s2_collected.is_set())
machine.remove_model(s2)
del s2
gc.collect()
self.assertTrue(s2_collected.is_set())
s3 = Dummy()
machine.add_model(s3)
s3.advance()
s3.advance()
self.assertTrue(s3.is_C())
def test_add_model_initial_state(self):
states = ['A', 'B', 'C', 'D', 'E', 'F']
machine = Machine(model=[], states=states, initial='A', name='Test Machine')
machine.add_transition('advance', 'A', 'B')
machine.add_transition('advance', 'B', 'C')
machine.add_transition('advance', 'C', 'D')
s1 = Dummy()
s2 = Dummy()
s3 = Dummy()
machine.add_model(s1)
machine.add_model(s2, initial='B')
machine.add_model(s3, initial='C')
s1.advance()
s2.advance()
s3.advance()
self.assertTrue(s1.is_B())
self.assertTrue(s2.is_C())
self.assertTrue(s3.is_D())
def test_add_model_no_initial_state(self):
states = ['A', 'B', 'C', 'D', 'E', 'F']
machine = Machine(model=[], states=states, name='Test Machine', initial=None)
machine.add_transition('advance', 'A', 'B')
machine.add_transition('advance', 'B', 'C')
machine.add_transition('advance', 'C', 'D')
s1 = Dummy()
s2 = Dummy()
s3 = Dummy()
with self.assertRaises(ValueError):
machine.add_model(s1)
machine.add_model(s1, initial='A')
machine.add_model(s2, initial='B')
machine.add_model(s3, initial='C')
s1.advance()
s2.advance()
s3.advance()
self.assertTrue(s1.is_B())
self.assertTrue(s2.is_C())
self.assertTrue(s3.is_D())
transitions-0.8.10+3/tox.ini 0000644 0002322 0002322 00000000765 14155650047 016213 0 ustar debalance debalance [tox]
envlist = py27, py37, py38, py39, py310, nogv, check-manifest
skip_missing_interpreters = True
[testenv]
deps = -rrequirements.txt
-rrequirements_diagrams.txt
-rrequirements_test.txt
commands = pytest -nauto --doctest-modules
[testenv:check-manifest]
deps = check-manifest
commands = check-manifest
[testenv:nogv]
deps = -rrequirements.txt
pytest
pytest-cov
pytest-xdist
mock
dill
pycodestyle
commands = pytest -nauto --doctest-modules