transitions-0.9.0/ 0000755 0002322 0002322 00000000000 14304350474 014447 5 ustar debalance debalance transitions-0.9.0/binder/ 0000755 0002322 0002322 00000000000 14304350474 015712 5 ustar debalance debalance transitions-0.9.0/binder/requirements.txt 0000644 0002322 0002322 00000000015 14304350474 021172 0 ustar debalance debalance six
graphviz
transitions-0.9.0/binder/postBuild 0000644 0002322 0002322 00000000043 14304350474 017577 0 ustar debalance debalance #!/bin/bash
set -ex
pip install .
transitions-0.9.0/binder/apt.txt 0000644 0002322 0002322 00000000011 14304350474 017227 0 ustar debalance debalance graphviz
transitions-0.9.0/setup.cfg 0000644 0002322 0002322 00000000265 14304350474 016273 0 ustar debalance debalance [metadata]
description_file = README.md
[check-manifest]
ignore =
.travis.yml
.scrutinizer.yml
appveyor.yml
[bdist_wheel]
universal = 1
[egg_info]
tag_build =
tag_date = 0
transitions-0.9.0/README.md 0000644 0002322 0002322 00000244556 14304350474 015746 0 ustar debalance debalance # transitions
[](https://github.com/pytransitions/transitions)
[](https://github.com/pytransitions/transitions/actions?query=workflow%3Apytest)
[](https://app.codecov.io/gh/pytransitions/transitions/tree/master)
[](https://pypi.org/project/transitions)
[](https://copr.fedorainfracloud.org/coprs/aleneum/python3-transitions/package/python3-transitions)
[](https://github.com/pytransitions/transitions/compare/0.8.11...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)
- [Check transitions](#check-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`:
```python
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.
#### Check transitions
If you want to check whether a transition is possible before you execute it ('look before you leap'), you can use `may_` convenience functions that have been attached to your model:
```python
# check if the current temperature is hot enough to trigger a transition
if lump.may_heat():
lump.heat()
```
This will execute all `prepare` callbacks and evaluate the conditions assigned to the potential transitions.
Transition checks can also be used when a transition's destination is not available (yet):
```python
machine.add_transition('elevate', 'solid', 'spiritual')
assert not lump.may_elevate() # not ready yet :(
```
#### 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 `asyncio.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.9.0/LICENSE 0000644 0002322 0002322 00000002112 14304350474 015450 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.9.0/.coveragerc 0000644 0002322 0002322 00000000113 14304350474 016563 0 ustar debalance debalance [run]
source = transitions
include = */transitions/*
relative_files = True
transitions-0.9.0/PKG-INFO 0000644 0002322 0002322 00000240373 14304350474 015555 0 ustar debalance debalance Metadata-Version: 2.1
Name: transitions
Version: 0.9.0
Summary: A lightweight, object-oriented Python state machine implementation with many extensions.
Home-page: http://github.com/pytransitions/transitions
Download-URL: https://github.com/pytransitions/transitions/archive/0.9.0.tar.gz
Author: Tal Yarkoni
Author-email: tyarkoni@gmail.com
Maintainer: Alexander Neumann
Maintainer-email: aleneum@gmail.com
License: MIT
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Description-Content-Type: text/markdown
Provides-Extra: diagrams
Provides-Extra: test
License-File: LICENSE
## 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`:
```python
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.
#### Check transitions
If you want to check whether a transition is possible before you execute it ('look before you leap'), you can use `may_` convenience functions that have been attached to your model:
```python
# check if the current temperature is hot enough to trigger a transition
if lump.may_heat():
lump.heat()
```
This will execute all `prepare` callbacks and evaluate the conditions assigned to the potential transitions.
Transition checks can also be used when a transition's destination is not available (yet):
```python
machine.add_transition('elevate', 'solid', 'spiritual')
assert not lump.may_elevate() # not ready yet :(
```
#### 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 `asyncio.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.9.0/requirements.txt 0000644 0002322 0002322 00000000004 14304350474 017725 0 ustar debalance debalance six
transitions-0.9.0/MANIFEST.in 0000644 0002322 0002322 00000000510 14304350474 016201 0 ustar debalance debalance include *.md
include *.txt
include .coveragerc
include .pylintrc
include LICENSE
include MANIFEST
include *.ini
include conftest.py
recursive-include transitions *.pyi
recursive-include examples *.ipynb
recursive-include tests *.py
recursive-exclude examples/.ipynb_checkpoints *.ipynb
recursive-include binder *.txt postBuild
transitions-0.9.0/Changelog.md 0000644 0002322 0002322 00000067344 14304350474 016676 0 ustar debalance debalance # Changelog
## 0.9.0 (September 2022)
Release 0.9.0 is a major release and contains improvements to ease development, adds some new features and removes the legacy hierarchical machine:
- removed legacy implementation of `HierarchicalMachine` from the package
- Bug #551: Fix active state styling in `GraphMachine` (thanks @betaboon)
- Bug #554: Fix issues related to scopes and queueing in `HierachicalMachine` (thanks @jankrejci)
- Bug #568: Reflexive transitions (dest: '=') had not been resolved correctly when source was a wildcard (thanks @jnu)
- Bug #568: HSM did not detect reflexive transitions if src was a parent state (thanks @lostcontrol)
- Bug #569: Fix implicit fallback to `graphviz` when `pygraphviz` was not installed (thanks @FridjofAmundsen)
- Bug #580: Fix `on_timeout` callback resolution when timeout had been initialized with `timeout=0` (thanks @Rysbai)
- Bug #582: Last label in `GraphSupport` was not correctly aligned when `show_attributes=True` (thanks @spagh-eddie)
- Feature: Add pyi stub files for better type hinting. Since many functions and constructors allow rather arbitrary arguments time will tell whether typing should be strict (and cause more mypy issues) or more relaxed (and thus less precise).
- Feature: Reviewed and improved method documentation
- Feature #549: Add `may` transition check to transitions (thanks @artofhuman)
- Feature #552: Refactored error handling to be able to handle `MachineError` in `on_exception` callbacks (thanks @kpihus)
- Feature: Add `mypy` to test workflow
- PR #461: Add `Retry` state to supported state stereotypes (thanks @rgov)
- Internal: `Machine._identify_callback` has been converted to instance method from class method
- Internal: `LockedMachine._get_qualified_state_name` has been converted to instance method from static method
- Internal: Removed `_super` workaround related to dill (see https://github.com/pytransitions/transitions/issues/236)
## 0.8.11 (February 2022)
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.9.0/requirements_diagrams.txt 0000644 0002322 0002322 00000000013 14304350474 021574 0 ustar debalance debalance pygraphviz
transitions-0.9.0/transitions/ 0000755 0002322 0002322 00000000000 14304350474 017024 5 ustar debalance debalance transitions-0.9.0/transitions/py.typed 0000644 0002322 0002322 00000000001 14304350474 020512 0 ustar debalance debalance
transitions-0.9.0/transitions/__init__.py 0000644 0002322 0002322 00000001001 14304350474 021125 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.9.0/transitions/version.py 0000644 0002322 0002322 00000000257 14304350474 021067 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.9.0'
transitions-0.9.0/transitions/core.pyi 0000644 0002322 0002322 00000024070 14304350474 020502 0 ustar debalance debalance from logging import Logger
from functools import partial
from typing import (
Any, Optional, Callable, Sequence, Union, Iterable, List, Dict, DefaultDict,
Type, Deque, OrderedDict, Tuple, Literal, Collection
)
# Enums are supported for Python 3.4+ and Python 2.7 with enum34 package installed
from enum import Enum, EnumMeta
_LOGGER: Logger
Callback = Union[str, Callable]
CallbackList = List[Callback]
CallbacksArg = Optional[Union[Callback, CallbackList]]
ModelState = Union[str, Enum, List]
ModelParameter = Union[Union[Literal['self'], Any], List[Union[Literal['self'], Any]]]
def listify(obj: Union[None, list, tuple, EnumMeta, Any]) -> Union[list, tuple, EnumMeta]: ...
def _prep_ordered_arg(desired_length: int, arguments: CallbacksArg) -> CallbackList: ...
class State:
dynamic_methods: List[str]
_name: Union[str, Enum]
ignore_invalid_triggers: bool
on_enter: CallbackList
on_exit: CallbackList
def __init__(self, name: Union[str, Enum], on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: bool = ...) -> None: ...
@property
def name(self) -> str: ...
@property
def value(self) -> Union[str, Enum]: ...
def enter(self, event_data: EventData) -> None: ...
def exit(self, event_data: EventData) -> None: ...
def add_callback(self, trigger: str, func: Callback) -> None: ...
def __repr__(self) -> str: ...
StateIdentifier = Union[str, Enum, State]
StateConfig = Union[StateIdentifier, Dict[str, Any], Collection[str]]
class Condition:
func: Callback
target: bool
def __init__(self, func: Callback, target: bool = ...) -> None: ...
def check(self, event_data: EventData) -> bool: ...
def __repr__(self) -> str: ...
class Transition:
dynamic_methods: List[str]
condition_cls: Type[Condition]
source: str
dest: str
prepare: CallbackList
before: CallbackList
after: CallbackList
conditions: List[Condition]
def __init__(self, source: str, dest: str, conditions: Optional[Condition] = ...,
unless: CallbacksArg = ..., before: CallbacksArg = ..., after: CallbacksArg = ...,
prepare: CallbacksArg = ...) -> None: ...
def _eval_conditions(self, event_data: EventData) -> bool: ...
def execute(self, event_data: EventData) -> bool: ...
def _change_state(self, event_data: EventData) -> None: ...
def add_callback(self, trigger: str, func: Callback) -> None: ...
def __repr__(self) -> str: ...
TransitionConfig = Union[Sequence[Union[str, Any]], Dict[str, Any], Transition]
class EventData:
state: Optional[State]
event: Optional[Event]
machine: Optional[Machine]
model: object
args: Iterable[Any]
kwargs: Dict[str, Any]
transition: Optional[Transition]
error: Optional[Exception]
result: Optional[bool]
def __init__(self, state: Optional[State], event: Optional[Event], machine: Machine, model: object,
args: Iterable[Any], kwargs: Dict[str, Any]) -> None: ...
def update(self, state: Union[State, str, Enum]) -> None: ...
def __repr__(self) -> str: ...
class Event:
name: str
machine: Machine
transitions: DefaultDict[str, List[Transition]]
def __init__(self, name: str, machine: Machine) -> None: ...
def add_transition(self, transition: Transition) -> None: ...
def trigger(self, model: object, *args: List, **kwargs: Dict) -> bool: ...
def _trigger(self, event_data: EventData) -> bool: ...
def _process(self, event_data: EventData) -> bool: ...
def _is_valid_source(self, state: State) -> bool: ...
def __repr__(self) -> str: ...
def add_callback(self, trigger: str, func: Callback) -> None: ...
class Machine:
separator: str
wildcard_all: str
wildcard_same: str
state_cls: Type[State]
transition_cls: Type[Transition]
event_cls: Type[Event]
self_literal: Literal['self']
_queued: bool
_transition_queue: Deque[partial]
_before_state_change: CallbackList
_after_state_change: CallbackList
_prepare_event: CallbackList
_finalize_event: CallbackList
_on_exception: CallbackList
_initial: Optional[str]
states: OrderedDict[str, State]
events: Dict[str, Event]
send_event: bool
auto_transitions: bool
ignore_invalid_triggers: Optional[bool]
name: str
model_attribute: str
models: List[Any]
def __init__(self, model: Optional[ModelParameter] = ...,
states: Optional[Union[Sequence[StateConfig], Type[Enum]]] = ...,
initial: Optional[StateIdentifier] = ...,
transitions: Optional[Union[TransitionConfig, Sequence[TransitionConfig]]] = ...,
send_event: bool = ..., auto_transitions: bool = ..., ordered_transitions: bool = ...,
ignore_invalid_triggers: Optional[bool] = ...,
before_state_change: CallbacksArg = ..., after_state_change: CallbacksArg = ...,
name: str = ..., queued: bool = ...,
prepare_event: CallbacksArg = ..., finalize_event: CallbacksArg = ...,
model_attribute: str = ..., on_exception: CallbacksArg = ..., **kwargs: Dict[str, Any]) -> None: ...
def add_model(self, model: ModelParameter,
initial: Optional[StateIdentifier] = ...) -> None: ...
def remove_model(self, model: ModelParameter) -> None: ...
@classmethod
def _create_transition(cls, *args: Any, **kwargs: Any) -> Transition: ...
@classmethod
def _create_event(cls, *args: Any, **kwargs: Any) -> Event: ...
@classmethod
def _create_state(cls, *args: Any, **kwargs: Any) -> State: ...
@property
def initial(self) -> Optional[str]: ...
@initial.setter
def initial(self, value: StateIdentifier) -> None: ...
@property
def has_queue(self) -> bool: ...
@property
def model(self) -> Union[object, List[object]]: ...
@property
def before_state_change(self) -> CallbackList: ...
@before_state_change.setter
def before_state_change(self, value: CallbacksArg) -> None: ...
@property
def after_state_change(self) -> CallbackList: ...
@after_state_change.setter
def after_state_change(self, value: CallbacksArg) -> None: ...
@property
def prepare_event(self) -> CallbackList: ...
@prepare_event.setter
def prepare_event(self, value: CallbacksArg) -> None: ...
@property
def finalize_event(self) -> CallbackList: ...
@finalize_event.setter
def finalize_event(self, value: CallbacksArg) -> None: ...
@property
def on_exception(self) -> CallbackList: ...
@on_exception.setter
def on_exception(self, value: CallbacksArg) -> None: ...
def get_state(self, state: Union[str, Enum]) -> State: ...
def is_state(self, state: Union[str, Enum], model: object) -> bool: ...
def get_model_state(self, model: object) -> State: ...
def set_state(self, state: StateIdentifier, model: Optional[object] = ...) -> None: ...
def add_state(self, states: Union[Sequence[StateConfig], StateConfig],
on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: Optional[bool] = ..., **kwargs: Dict[str, Any]) -> None: ...
def add_states(self, states: Union[Sequence[StateConfig], StateConfig],
on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: Optional[bool] = ..., **kwargs: Dict[str, Any]) -> None: ...
def _add_model_to_state(self, state: State, model: object) -> None: ...
def _checked_assignment(self, model: object, name: str, func: Callable) -> None: ...
def _add_trigger_to_model(self, trigger: str, model: object) -> None: ...
def _get_trigger(self, model: object, trigger_name: str, *args: List, **kwargs: Dict[str, Any]) -> bool: ...
def get_triggers(self, *args: Union[str, Enum, State]) -> List[str]: ...
def add_transition(self, trigger: str,
source: Union[StateIdentifier, List[StateIdentifier]],
dest: Optional[StateIdentifier] = ...,
conditions: CallbacksArg = ..., unless: CallbacksArg = ...,
before: CallbacksArg = ..., after: CallbacksArg = ..., prepare: CallbacksArg = ...,
**kwargs: Dict[str, Any]) -> None: ...
def add_transitions(self, transitions: Union[TransitionConfig, List[TransitionConfig]]) -> None: ...
def add_ordered_transitions(self, states: Optional[Sequence[Union[str, State]]] = ...,
trigger: str = ..., loop: bool = ...,
loop_includes_initial: bool = ...,
conditions: Optional[Sequence[Union[Callback, None]]] = ...,
unless: Optional[Sequence[Union[Callback, None]]] = ...,
before: Optional[Sequence[Union[Callback, None]]] = ...,
after: Optional[Sequence[Union[Callback, None]]] = ...,
prepare: CallbacksArg = ...,
**kwargs: Dict[str, Any]) -> None: ...
def get_transitions(self, trigger: str = ...,
source: StateIdentifier = ..., dest: StateIdentifier = ...) -> List[Transition]: ...
def remove_transition(self, trigger: str, source: str = ..., dest: str = ...) -> None: ...
def dispatch(self, trigger: str, *args: List, **kwargs: Dict[str, Any]) -> bool: ...
def callbacks(self, funcs: Iterable[Union[str, Callable]], event_data: EventData) -> None: ...
def callback(self, func: Union[str, Callable], event_data: EventData) -> None: ...
@staticmethod
def resolve_callable(func: Union[str, Callable], event_data: EventData) -> Callable: ...
def _has_state(self, state: StateIdentifier, raise_error: bool = ...) -> bool: ...
def _process(self, trigger: partial) -> bool: ...
def _identify_callback(self, name: str) -> Tuple[Optional[str], Optional[str]]: ...
def __getattr__(self, name: str) -> Any: ...
class MachineError(Exception):
value: str
def __init__(self, value: str) -> None: ...
def __str__(self) -> str: ...
transitions-0.9.0/transitions/core.py 0000644 0002322 0002322 00000166147 14304350474 020345 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: # type:ignore
""" This is just an Enum stub for Python 2 and Python 3.3 and before without Enum support. """
class EnumMeta: # type:ignore
""" This is just an EnumMeta stub for Python 2 and Python 3.3 and before without Enum support. """
import inspect
import itertools
import logging
import warnings
from collections import OrderedDict, defaultdict, deque
from functools import partial
from six import string_types
_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):
""" The name of the state. """
if isinstance(self._name, Enum):
return self._name.name
return self._name
@property
def value(self):
""" The state's value. For string states this will be equivalent to the name attribute. """
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 (str or 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 or callable): 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 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 or callable): The name of the callback function or a callable.
"""
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 (Exception): 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 a transition was
successfully executed (True if successful, False if not).
"""
func = partial(self._trigger, EventData(None, self, self.machine, model, args=args, kwargs=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, event_data):
""" Internal trigger function called by the ``Machine`` instance. This should not
be called directly but via the public method ``Machine.process``.
Args:
event_data (EventData): The currently processed event. State, result and (potentially) error might be
overridden.
Returns: boolean indicating whether a transition was
successfully executed (True if successful, False if not).
"""
event_data.state = self.machine.get_model_state(event_data.model)
try:
if self._is_valid_source(event_data.state):
self._process(event_data)
except Exception as err: # pylint: disable=broad-except; Exception will be handled elsewhere
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: # pylint: disable=broad-except; Exception will be handled elsewhere
_LOGGER.error("%sWhile executing finalize callbacks a %s occurred: %s.",
self.machine.name,
type(err).__name__,
str(err))
return event_data.result
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)
for trans in self.transitions[event_data.state.name]:
event_data.transition = trans
if trans.execute(event_data):
event_data.result = True
break
def _is_valid_source(self, state):
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
raise MachineError(msg)
return True
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.")
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].model 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_states(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_states(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 or Enum): name of the checked state or Enum
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):
"""
Get the state of a model
Args:
model (object): the stateful model
Returns:
State: The State object related to the model's state
"""
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, states, on_enter=None, on_exit=None, ignore_invalid_triggers=None, **kwargs):
""" Alias for add_states. """
self.add_states(states=states, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers, **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(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(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, 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 _can_trigger(self, model, trigger, *args, **kwargs):
evt = EventData(None, None, self, model, args, kwargs)
state = self.get_model_state(model).name
for trigger_name in self.get_triggers(state):
if trigger_name != trigger:
continue
for transition in self.events[trigger_name].transitions[state]:
try:
_ = self.get_state(transition.dest)
except ValueError:
continue
self.callbacks(self.prepare_event, evt)
self.callbacks(transition.prepare, evt)
if all(c.check(evt) for c in transition.conditions):
return True
return False
def _add_may_transition_func_for_trigger(self, trigger, model):
self._checked_assignment(model, "may_%s" % trigger, partial(self._can_trigger, model, trigger))
def _add_trigger_to_model(self, trigger, model):
self._checked_assignment(model, trigger, partial(self.events[trigger].trigger, model))
self._add_may_transition_func_for_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 = {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, Enum 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 or Enum): 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 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, Enum or State): Limits removal to transitions from a certain state.
dest (str, Enum or State): 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:
module_name, func_name = func.rsplit('.', 1)
module = __import__(module_name)
for submodule_name in module_name.split('.')[1:]:
module = getattr(module, submodule_name)
func = getattr(module, func_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()
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
def _identify_callback(self, name):
# Does the prefix match a known callback?
for callback in itertools.chain(self.state_cls.dynamic_methods, self.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(self.separator):]
# Make sure there is actually a target to avoid index error and enforce _ as a separator
if target == '' or name[len(callback_type)] != self.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)
if 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)
transitions-0.9.0/transitions/__init__.pyi 0000644 0002322 0002322 00000000410 14304350474 021301 0 ustar debalance debalance from .core import Event as Event, EventData as EventData, Machine as Machine, MachineError as MachineError, State as State, Transition as Transition
from .version import __version__ as __version__
__copyright__: str
__license__: str
__summary__: str
__uri__: str
transitions-0.9.0/transitions/extensions/ 0000755 0002322 0002322 00000000000 14304350474 021223 5 ustar debalance debalance transitions-0.9.0/transitions/extensions/diagrams_graphviz.pyi 0000644 0002322 0002322 00000005000 14304350474 025442 0 ustar debalance debalance from ..core import State, ModelState
from .diagrams import GraphMachine
from .diagrams_base import BaseGraph
from logging import Logger
from typing import Type, Optional, Dict, List, Union, IO, DefaultDict, Any
try:
from graphviz import Digraph
from graphviz.dot import SubgraphContext
except ImportError:
class Digraph: # type: ignore
pass
class SubgraphContext: # type: ignore
pass
_LOGGER: Logger
class Graph(BaseGraph):
custom_styles: Dict[str, DefaultDict]
def __init__(self, machine: Type[GraphMachine]) -> None: ...
def set_previous_transition(self, src: str, dst: str) -> None: ...
def set_node_style(self, state: ModelState, style: str) -> None: ...
def reset_styling(self) -> None: ...
def _add_nodes(self, states: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: Union[Digraph, SubgraphContext]) -> None: ...
def _add_edges(self, transitions: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: Union[Digraph, SubgraphContext]) -> None: ...
def generate(self) -> None: ...
def get_graph(self, title: Optional[str] = ..., # type: ignore[no-any-unimported]
roi_state: Optional[str] = ...) -> Digraph: ...
def draw(self, filename: Optional[Union[str, IO]], format:Optional[str] = ...,
prog: Optional[str] = ..., args:str = ...) -> Optional[str]: ...
class NestedGraph(Graph):
_cluster_states: List[str]
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def set_previous_transition(self, src: str, dst: str) -> None: ...
def _add_nodes(self, states: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: Union[Digraph, SubgraphContext]) -> None: ...
def _add_nested_nodes(self, # type: ignore[no-any-unimported]
states: List[Dict[str, Union[str, List[Dict[str, str]]]]],
container: Union[Digraph, SubgraphContext],
prefix: str, default_style: str) -> None: ...
def _add_edges(self, transitions: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: Union[Digraph, SubgraphContext]) -> None: ...
def _create_edge_attr(self, src: str, dst: str, transition: Dict[str, str]) -> Dict[str, Any]: ...
def _filter_states(states: List[Dict[str, str]], state_names: List[str], state_cls: Type[State],
prefix: Optional[List[str]] = ...) -> List[Dict[str, str]]: ...
transitions-0.9.0/transitions/extensions/diagrams.py 0000644 0002322 0002322 00000030573 14304350474 023374 0 ustar debalance debalance """
transitions.extensions.diagrams
-------------------------------
This module contains machine and transition definitions for generating diagrams from machine instances.
It uses Graphviz either directly with the help of pygraphviz (https://pygraphviz.github.io/) or loosely
coupled via dot graphs with the graphviz module (https://github.com/xflr6/graphviz).
Pygraphviz accesses libgraphviz directly and also features more functionality considering graph manipulation.
However, especially on Windows, compiling the required extension modules can be tricky.
Furthermore, some pygraphviz issues are platform-dependent as well.
Graphviz generates a dot graph and calls the `dot` executable to generate diagrams and thus is commonly easier to
set up. Make sure that the `dot` executable is in your PATH.
"""
import logging
from functools import partial
from transitions import Transition
from ..core import listify
from .markup import MarkupMachine, HierarchicalMarkupMachine
from .nesting import NestedTransition
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
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)
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
graph.set_node_style(getattr(event_data.model, event_data.machine.model_attribute), "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)
except AttributeError as err:
_LOGGER.warning("Graph for model could not be initialized after pickling: %s", err)
def __init__(self, model=MarkupMachine.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,
title="State Machine", show_conditions=False, show_state_attributes=False, show_auto_transitions=False,
use_pygraphviz=True, **kwargs):
# remove graph config from keywords
self.title = title
self.show_conditions = show_conditions
self.show_state_attributes = show_state_attributes
# in MarkupMachine this switch is called 'with_auto_transitions'
# keep 'auto_transitions_markup' for backwards compatibility
kwargs["auto_transitions_markup"] = show_auto_transitions
self.model_graphs = {}
self.graph_cls = self._init_graphviz_engine(use_pygraphviz)
_LOGGER.debug("Using graph engine %s", self.graph_cls)
super(GraphMachine, self).__init__(
model=model, states=states, initial=initial, transitions=transitions,
send_event=send_event, auto_transitions=auto_transitions,
ordered_transitions=ordered_transitions, ignore_invalid_triggers=ignore_invalid_triggers,
before_state_change=before_state_change, after_state_change=after_state_change, name=name,
queued=queued, prepare_event=prepare_event, finalize_event=finalize_event,
model_attribute=model_attribute, on_exception=on_exception, **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):
""" Imports diagrams (py)graphviz backend based on machine configuration """
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 ( # pylint: disable=import-outside-toplevel
NestedGraph as Graph, pgv
)
self.machine_attributes.update(self.hierarchical_machine_attributes)
else:
from .diagrams_pygraphviz import ( # pylint: disable=import-outside-toplevel
Graph, pgv
)
if pgv is None:
raise ImportError
return Graph
except ImportError:
_LOGGER.warning("Could not import pygraphviz backend. Will try graphviz backend next")
if hasattr(self.state_cls, "separator") and hasattr(self, "__enter__"):
from .diagrams_graphviz import ( # pylint: disable=import-outside-toplevel
NestedGraph as Graph,
)
self.machine_attributes.update(self.hierarchical_machine_attributes)
else:
from .diagrams_graphviz import Graph # pylint: disable=import-outside-toplevel
return Graph
def _get_graph(self, model, title=None, force_new=False, show_roi=False):
""" This method will be bound as a partial to models and return a graph object to be drawn or manipulated.
Args:
model (object): The model that `_get_graph` was bound to. This parameter will be set by `GraphMachine`.
title (str): The title of the created graph.
force_new (bool): Whether a new graph should be generated even if another graph already exists. This should
be true whenever the model's state or machine's transitions/states/events have changed.
show_roi (bool): If set to True, only render states that are active and/or can be reached from
the current state.
Returns: AGraph (pygraphviz) or Digraph (graphviz) graph instance that can be drawn.
"""
if force_new:
graph = self.graph_cls(self)
self.model_graphs[id(model)] = graph
try:
graph.set_node_style(getattr(model, self.model_attribute), "active")
except AttributeError:
_LOGGER.info("Could not set active state of diagram")
try:
graph = self.model_graphs[id(model)]
except KeyError:
_ = self._get_graph(model, title, force_new=True)
graph = self.model_graphs[id(model)]
return graph.get_graph(title=title, roi_state=getattr(model, self.model_attribute) if show_roi else None)
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): Whether a new graph should be generated even if another graph already exists. This should
be true whenever the model's state or machine's transitions/states/events have changed.
show_roi (bool): If set to True, only render states that are active and/or can be reached from
the current state.
Returns: AGraph (pygraphviz) or Digraph (graphviz) graph instance that can be drawn.
"""
_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 NestedGraphTransition(TransitionGraphSupport, NestedTransition):
"""
A transition type to be used with (subclasses of) `HierarchicalGraphMachine` and
`LockedHierarchicalGraphMachine`.
"""
class HierarchicalGraphMachine(GraphMachine, HierarchicalMarkupMachine):
"""
A hierarchical state machine with graph support.
"""
transition_cls = NestedGraphTransition
transitions-0.9.0/transitions/extensions/diagrams_pygraphviz.pyi 0000644 0002322 0002322 00000003623 14304350474 026024 0 ustar debalance debalance from typing import Any, List, Dict, Union, Optional
from logging import Logger
from .diagrams_base import BaseGraph
from ..core import ModelState
try:
from pygraphviz import AGraph
except ImportError:
class AGraph: # type: ignore
style_attributes: Dict[str, Union[str, Dict[str, Union[str, Dict[str, str]]]]]
_LOGGER: Logger
class Graph(BaseGraph):
fsm_graph: AGraph # type: ignore[no-any-unimported]
def _add_nodes(self, states: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: AGraph) -> None: ...
def _add_edges(self, transitions: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: AGraph) -> None: ...
def generate(self) -> None: ...
def get_graph(self, title: Optional[str] = ..., # type: ignore[no-any-unimported]
roi_state: Optional[str] = ...) -> AGraph: ...
def set_node_style(self, state: ModelState, style: str) -> None: ...
def set_previous_transition(self, src: str, dst: str) -> None: ...
def reset_styling(self) -> None: ...
class NestedGraph(Graph):
seen_transitions: Any
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def _add_nodes(self, # type: ignore[override, no-any-unimported]
states: List[Dict[str, Union[str, List[Dict[str, str]]]]],
container: AGraph, prefix: str = ..., default_style: str = ...) -> None: ...
def _add_edges(self, transitions: List[Dict[str, str]], # type: ignore[no-any-unimported]
container: AGraph) -> None: ...
def set_node_style(self, state: ModelState, style: str) -> None: ...
def set_previous_transition(self, src: str, dst: str) -> None: ...
def _get_subgraph(graph: AGraph, name: str) -> Optional[AGraph]: ... # type: ignore[no-any-unimported]
def _copy_agraph(graph: AGraph) -> AGraph: ... # type: ignore[no-any-unimported]
transitions-0.9.0/transitions/extensions/factory.py 0000644 0002322 0002322 00000010442 14304350474 023245 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, Transition
from .nesting import HierarchicalMachine, NestedEvent, NestedTransition
from .locking import LockedMachine
from .diagrams import GraphMachine, NestedGraphTransition, HierarchicalGraphMachine
try:
from transitions.extensions.asyncio import AsyncMachine, AsyncTransition
from transitions.extensions.asyncio import HierarchicalAsyncMachine, NestedAsyncTransition
except (ImportError, SyntaxError):
class AsyncMachine(Machine): # type: ignore
""" A mock of AsyncMachine for Python 3.6 and earlier. """
class AsyncTransition(Transition): # type: ignore
""" A mock of AsyncTransition for Python 3.6 and earlier. """
class HierarchicalAsyncMachine(HierarchicalMachine): # type: ignore
""" A mock of HierarchicalAsyncMachine for Python 3.6 and earlier. """
class NestedAsyncTransition(NestedTransition): # type: ignore
""" A mock of NestedAsyncTransition for Python 3.6 and earlier. """
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") # from KeyError
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):
""" A machine that supports asynchronous event/callback processing with Graphviz support. """
transition_cls = AsyncTransition
class HierarchicalAsyncGraphMachine(GraphMachine, HierarchicalAsyncMachine):
""" A hierarchical machine that supports asynchronous event/callback processing with Graphviz support. """
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.9.0/transitions/extensions/__init__.py 0000644 0002322 0002322 00000001460 14304350474 023335 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, HierarchicalGraphMachine
from .nesting import HierarchicalMachine
from .locking import LockedMachine
from .factory import MachineFactory, LockedHierarchicalGraphMachine
from .factory import LockedHierarchicalMachine, LockedGraphMachine
try:
# only available for Python 3
from .asyncio import AsyncMachine, HierarchicalAsyncMachine
from .factory import AsyncGraphMachine, HierarchicalAsyncGraphMachine
except (ImportError, SyntaxError):
pass
transitions-0.9.0/transitions/extensions/diagrams_base.py 0000644 0002322 0002322 00000013300 14304350474 024353 0 ustar debalance debalance """
transitions.extensions.diagrams_base
------------------------------------
The class BaseGraph implements the common ground for Graphviz backends.
"""
import copy
import abc
import logging
import six
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
@six.add_metaclass(abc.ABCMeta)
class BaseGraph(object):
""" Provides the common foundation for graphs generated either with pygraphviz or graphviz. This abstract class
should not be instantiated directly. Use .(py)graphviz.(Nested)Graph instead.
Attributes:
machine (GraphMachine): The associated GraphMachine
fsm_graph (object): The AGraph-like object that holds the graphviz information
"""
def __init__(self, machine):
self.machine = machine
self.fsm_graph = None
self.generate()
@abc.abstractmethod
def generate(self):
""" Triggers the generation of a graph. """
@abc.abstractmethod
def set_previous_transition(self, src, dst):
""" Sets the styling of an edge to 'previous'
Args:
src (str): Name of the source state
dst (str): Name of the destination
"""
@abc.abstractmethod
def reset_styling(self):
""" Resets the styling of the currently generated graph. """
@abc.abstractmethod
def set_node_style(self, state, style):
""" Sets the style of nodes associated with a model state
Args:
state (str, Enum or list): Name of the state(s) or Enum(s)
style (str): Name of the style
"""
@abc.abstractmethod
def get_graph(self, title=None, roi_state=None):
""" Returns a graph object.
Args:
title (str): Title of the generated graph
roi_state (State): If not None, the returned graph will only contain edges and states connected to it.
Returns:
A graph instance with a `draw` that allows to render the graph.
"""
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']) + ')'
# end each label with a left-aligned newline
return label + r"\l"
def _get_state_names(self, state):
if isinstance(state, (list, tuple, set)):
for res in state:
for inner in self._get_state_names(res):
yield inner
else:
yield self.machine.state_cls.separator.join(self.machine._get_enum_path(state))\
if hasattr(state, "name") else state
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"]):
edge_label = "{edge_label} [{conditions}]".format(
edge_label=edge_label,
conditions=" & ".join(
tran.get("conditions", []) + ["!" + u for u in tran.get("unless", [])]
),
)
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()
queue = [([], markup)]
while queue:
prefix, scope = queue.pop(0)
for transition in scope.get("transitions", []):
if prefix:
tran = copy.copy(transition)
tran["source"] = self.machine.state_cls.separator.join(
prefix + [tran["source"]]
)
if "dest" in tran: # don't do this for internal transitions
tran["dest"] = self.machine.state_cls.separator.join(
prefix + [tran["dest"]]
)
else:
tran = transition
transitions.append(tran)
for state in scope.get("children", []) + scope.get("states", []):
if not prefix:
sta = state
states.append(sta)
ini = state.get("initial", [])
if not isinstance(ini, list):
ini = ini.name if hasattr(ini, "name") else ini
tran = 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(tran)
if state.get("children", []):
queue.append((prefix + [state["name"]], state))
except KeyError:
_LOGGER.error("Graph creation incomplete!")
return states, transitions
transitions-0.9.0/transitions/extensions/diagrams.pyi 0000644 0002322 0002322 00000007637 14304350474 023552 0 ustar debalance debalance from transitions.core import (
StateIdentifier, StateConfig, CallbacksArg, Transition, EventData, TransitionConfig, ModelParameter
)
from transitions.extensions.nesting import NestedTransition
from transitions.extensions.diagrams_base import BaseGraph, GraphModelProtocol, GraphProtocol
from transitions.extensions.markup import MarkupMachine, HierarchicalMarkupMachine
from logging import Logger
from typing import Any, Literal, Sequence, Type, List, Dict, Union, Optional, Generator
from enum import Enum
_LOGGER: Logger
# mypy does not support cyclic definitions (yet)
# thus we cannot use Dict[str, 'GraphvizParameters'] and have to fall back to Any
GraphvizParameters = Dict[str, Union[str, Dict[str, Any]]]
class TransitionGraphSupport(Transition):
label: str
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def _change_state(self, event_data: EventData) -> None: ...
class GraphMachine(MarkupMachine):
_pickle_blacklist: List[str]
transition_cls: Type[TransitionGraphSupport]
machine_attributes: Dict[str, str]
hierarchical_machine_attributes:Dict [str, str]
style_attributes: Dict[str, Union[str, Dict[str, Union[str, Dict[str, Any]]]]]
model_graphs: Dict[int, BaseGraph]
title: str
show_conditions: bool
show_state_attributes: bool
graph_cls: Type[BaseGraph]
models: List[GraphModelProtocol]
def __getstate__(self) -> Dict[str, Any]: ...
def __setstate__(self, state: Dict[str, Any]) -> None: ...
def __init__(self, model: Optional[ModelParameter]=...,
states: Optional[Union[Sequence[StateConfig], Type[Enum]]] = ...,
initial: Optional[StateIdentifier] = ...,
transitions: Optional[Union[TransitionConfig, List[TransitionConfig]]] = ..., send_event: bool = ...,
auto_transitions: bool = ..., ordered_transitions: bool = ...,
ignore_invalid_triggers: Optional[bool] = ...,
before_state_change: CallbacksArg = ..., after_state_change: CallbacksArg = ...,
name: str = ..., queued: bool = ...,
prepare_event: CallbacksArg = ..., finalize_event: CallbacksArg = ...,
model_attribute: str = ..., on_exception: CallbacksArg = ...,
title: str = ..., show_conditions: bool = ..., show_state_attributes: bool = ...,
show_auto_transitions: bool = ..., use_pygraphviz: bool = ..., **kwargs: Dict[str, Any]) -> None: ...
def _init_graphviz_engine(self, use_pygraphviz: bool) -> Type[BaseGraph]: ...
def _get_graph(self, model: GraphModelProtocol, title: Optional[str] = ..., force_new: bool = ...,
show_roi: bool = ...) -> GraphProtocol: ...
def get_combined_graph(self, title: Optional[str] = ..., force_new: bool = ...,
show_roi: bool = ...) -> GraphProtocol: ...
def add_model(self, model: Union[Union[Literal['self'], object], List[Union[Literal['self'], object]]],
initial: Optional[StateIdentifier] = ...) -> None: ...
def add_states(self, states: Union[Sequence[StateConfig], StateConfig],
on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: Optional[bool] = ..., **kwargs: Dict[str, Any]) -> None: ...
def add_transition(self, trigger: str,
source: Union[StateIdentifier, List[StateIdentifier]],
dest: Optional[StateIdentifier] = ...,
conditions: CallbacksArg = ..., unless: CallbacksArg = ...,
before: CallbacksArg = ..., after: CallbacksArg = ..., prepare: CallbacksArg = ...,
**kwargs: Dict[str, Any]) -> None: ...
class NestedGraphTransition(TransitionGraphSupport, NestedTransition): ...
class HierarchicalGraphMachine(GraphMachine, HierarchicalMarkupMachine): # type: ignore
transition_cls: Type[NestedGraphTransition]
transitions-0.9.0/transitions/extensions/asyncio.pyi 0000644 0002322 0002322 00000014450 14304350474 023417 0 ustar debalance debalance from ..core import Condition, Event, EventData, Machine, State, Transition, StateConfig, ModelParameter, TransitionConfig
from .nesting import HierarchicalMachine, NestedEvent, NestedState, NestedTransition
from typing import Any, Optional, List, Type, Dict, Deque, Callable, Union, Iterable, DefaultDict, Literal, Sequence
from asyncio import Task
from functools import partial
from logging import Logger
from enum import Enum
from contextvars import ContextVar
from ..core import StateIdentifier, CallbacksArg, CallbackList
_LOGGER: Logger
class AsyncState(State):
async def enter(self, event_data: AsyncEventData) -> None: ... # type: ignore[override]
async def exit(self, event_data: AsyncEventData) -> None: ... # type: ignore[override]
class NestedAsyncState(NestedState, AsyncState):
_scope: Any
async def scoped_enter(self, event_data: AsyncEventData, scope: Optional[List[str]] = ...) -> None: ... # type: ignore[override]
async def scoped_exit(self, event_data: AsyncEventData, scope: Optional[List[str]] = ...) -> None: ... # type: ignore[override]
class AsyncCondition(Condition):
async def check(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
class AsyncTransition(Transition):
condition_cls: Type[AsyncCondition]
async def _eval_conditions(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
async def execute(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
async def _change_state(self, event_data: AsyncEventData) -> None: ... # type: ignore[override]
class NestedAsyncTransition(AsyncTransition, NestedTransition):
async def _change_state(self, event_data: AsyncEventData) -> None: ... # type: ignore[override]
class AsyncEventData(EventData):
machine: Union[AsyncMachine, HierarchicalAsyncMachine]
transition: AsyncTransition
source_name: Optional[str]
source_path: Optional[List[str]]
class AsyncEvent(Event):
machine: AsyncMachine
transitions: DefaultDict[str, List[AsyncTransition]] # type: ignore
async def trigger(self, model: object, *args: List, **kwargs: Dict[str, Any]) -> bool: ... # type: ignore[override]
async def _trigger(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
async def _process(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
class NestedAsyncEvent(NestedEvent):
transitions: DefaultDict[str, List[NestedAsyncTransition]] # type: ignore
async def trigger_nested(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
async def _process(self, event_data: AsyncEventData) -> bool: ... # type: ignore[override]
class AsyncMachine(Machine):
state_cls: Type[NestedAsyncState]
transition_cls: Type[AsyncTransition]
event_cls: Type[AsyncEvent]
async_tasks: Dict[int, List[Task]]
events: Dict[str, AsyncEvent] # type: ignore
queued: Union[bool, Literal["model"]]
protected_tasks: List[Task]
current_context: ContextVar
_transition_queue_dict: Dict[int, Deque[Callable]]
def __init__(self, model: Optional[ModelParameter] = ...,
states: Optional[Union[Sequence[StateConfig], Type[Enum]]] = ...,
initial: Optional[StateIdentifier] = ...,
transitions: Optional[Union[TransitionConfig, Sequence[TransitionConfig]]] = ...,
send_event: bool = ..., auto_transitions: bool = ..., ordered_transitions: bool = ...,
ignore_invalid_triggers: Optional[bool] = ...,
before_state_change: CallbacksArg = ..., after_state_change: CallbacksArg = ...,
name: str = ..., queued: Union[bool, Literal["model"]] = ...,
prepare_event: CallbacksArg = ..., finalize_event: CallbacksArg = ...,
model_attribute: str = ..., on_exception: CallbacksArg = ..., **kwargs: Dict[str, Any]) -> None: ...
def add_model(self, model: Union[Union[Literal["self"], object], Sequence[Union[Literal["self"], object]]],
initial: Optional[StateIdentifier] = ...) -> None: ...
async def dispatch(self, trigger: str, *args: List, **kwargs: Dict[str, Any]) -> bool: ... # type: ignore[override]
async def callbacks(self, funcs: Iterable[Union[str, Callable]], event_data: AsyncEventData) -> None: ... # type: ignore[override]
async def callback(self, func: Union[str, Callable], event_data: AsyncEventData) -> None: ... # type: ignore[override]
@staticmethod
async def await_all(callables: List[Callable]) -> List: ...
async def switch_model_context(self, model: object) -> None: ...
def get_state(self, state: Union[str, Enum]) -> AsyncState: ...
async def process_context(self, func: partial, model: object) -> bool: ...
def remove_model(self, model: object) -> None: ...
def _process(self, trigger: partial) -> bool: ...
async def _process_async(self, trigger: partial, model: object) -> bool: ...
class HierarchicalAsyncMachine(HierarchicalMachine, AsyncMachine): # type: ignore
state_cls: Type[NestedAsyncState]
transition_cls: Type[NestedAsyncTransition]
event_cls: Type[NestedAsyncEvent] # type: ignore
async def trigger_event(self, model: object, trigger: str, # type: ignore[override]
*args: List, **kwargs: Dict[str, Any]) -> bool: ...
async def _trigger_event(self, event_data: AsyncEventData, trigger: str) -> bool: ... # type: ignore[override]
class AsyncTimeout(AsyncState):
dynamic_methods: List[str]
timeout: float
_on_timeout: CallbacksArg
runner: Dict[int, Task]
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
async def enter(self, event_data: AsyncEventData) -> None: ... # type: ignore[override]
async def exit(self, event_data: AsyncEventData) -> None: ... # type: ignore[override]
def create_timer(self, event_data: AsyncEventData) -> Task: ...
async def _process_timeout(self, event_data: AsyncEventData) -> None: ...
@property
def on_timeout(self) -> CallbackList: ...
@on_timeout.setter
def on_timeout(self, value: CallbacksArg) -> None: ...
class _DictionaryMock(dict):
_value: Any
def __init__(self, item: Any) -> None: ...
def __setitem__(self, key: Any, item: Any) -> None: ...
def __getitem__(self, key: Any) -> Any: ...
def __repr__(self) -> str: ...
transitions-0.9.0/transitions/extensions/locking.pyi 0000644 0002322 0002322 00000006274 14304350474 023405 0 ustar debalance debalance from transitions.core import Event, Machine, ModelParameter, TransitionConfig, CallbacksArg, StateConfig
from typing import Any, Dict, ContextManager, Literal, Optional, Type, List, DefaultDict, Union, Callable, Sequence
from types import TracebackType
from logging import Logger
from threading import Lock
from ..core import StateIdentifier, State
_LOGGER: Logger
from enum import Enum
class PicklableLock(ContextManager):
lock: Lock
def __init__(self) -> None: ...
def __getstate__(self) -> Dict[str, Any]: ...
def __setstate__(self, value: Dict[str, Any]) -> PicklableLock: ...
def __enter__(self) -> None: ...
def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
exc_tb: Optional[TracebackType]) -> None: ...
class IdentManager(ContextManager):
current: int
def __init__(self) -> None: ...
def __enter__(self) -> None: ...
def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
exc_tb: Optional[TracebackType]) -> None: ...
class LockedEvent(Event):
machine: LockedMachine
def trigger(self, model: object, *args: List, **kwargs: Dict[str, Any]) -> bool: ...
class LockedMachine(Machine):
event_cls: Type[LockedEvent]
_ident: IdentManager
machine_context: List[ContextManager]
model_context_map: DefaultDict[int, List[ContextManager]]
def __init__(self, model: Optional[ModelParameter] = ...,
states: Optional[Union[Sequence[StateConfig], Type[Enum]]] = ...,
initial: Optional[StateIdentifier] = ...,
transitions: Optional[Union[TransitionConfig, Sequence[TransitionConfig]]] = ...,
send_event: bool = ..., auto_transitions: bool = ..., ordered_transitions: bool = ...,
ignore_invalid_triggers: Optional[bool] = ...,
before_state_change: CallbacksArg = ..., after_state_change: CallbacksArg = ...,
name: str = ..., queued: bool = ...,
prepare_event: CallbacksArg = ..., finalize_event: CallbacksArg = ...,
model_attribute: str = ..., on_exception: CallbacksArg = ...,
machine_context: Optional[Union[List[ContextManager], ContextManager]] = ...,
**kwargs: Dict[str, Any]) -> None: ...
def __getstate__(self) -> Dict[str, Any]: ...
def __setstate__(self, state: Dict[str, Any]) -> None: ...
def add_model(self, model: Union[Union[Literal['self'], object], List[Union[Literal['self'], object]]],
initial: Optional[StateIdentifier] = ...,
model_context: Optional[Union[ContextManager, List[ContextManager]]] = ...) -> None: ...
def remove_model(self, model: Union[Union[Literal['self'], object],
List[Union[Literal['self'], object]]]) -> None: ...
def __getattribute__(self, item: str) -> Any: ...
def __getattr__(self, item: str) -> Any: ...
def _add_model_to_state(self, state: State, model: object) -> None: ...
def _get_qualified_state_name(self, state: State) -> str: ...
def _locked_method(self, func: Callable, *args: List, **kwargs: Dict[str, Any]) -> Any: ...
transitions-0.9.0/transitions/extensions/markup.pyi 0000644 0002322 0002322 00000006646 14304350474 023261 0 ustar debalance debalance import numbers
from ..core import Machine, StateIdentifier, CallbacksArg, StateConfig, Event, TransitionConfig, ModelParameter
from .nesting import HierarchicalMachine
from typing import List, Dict, Union, Optional, Callable, Tuple, Any, Type, Sequence, TypedDict
from enum import Enum
# mypy does not support recursive definitions (yet), we need to use Any instead of 'MarkupConfig'
class MarkupConfig(TypedDict):
transitions: List[TransitionConfig]
class MarkupMachine(Machine):
state_attributes: List[str]
transition_attributes: List[str]
_markup: MarkupConfig
_auto_transitions_markup: bool
_needs_update: bool
def __init__(self, model: Optional[ModelParameter]=...,
states: Optional[Union[Sequence[StateConfig], Type[Enum]]] = ...,
initial: Optional[StateIdentifier] = ...,
transitions: Optional[Union[TransitionConfig, Sequence[TransitionConfig]]] = ...,
send_event: bool = ..., auto_transitions: bool = ..., ordered_transitions: bool = ...,
ignore_invalid_triggers: Optional[bool] = ...,
before_state_change: CallbacksArg = ..., after_state_change: CallbacksArg = ...,
name: str = ..., queued: bool = ...,
prepare_event: CallbacksArg = ..., finalize_event: CallbacksArg = ...,
model_attribute: str = ..., on_exception: CallbacksArg = ...,
markup: Optional[MarkupConfig] = ..., auto_transitions_markup: bool = ...,
**kwargs: Dict[str, Any]) -> None: ...
@property
def auto_transitions_markup(self) -> bool: ...
@auto_transitions_markup.setter
def auto_transitions_markup(self, value: bool) -> None: ...
@property
def markup(self) -> MarkupConfig: ...
def get_markup_config(self) -> MarkupConfig: ...
def add_transition(self, trigger: str,
source: Union[StateIdentifier, List[StateIdentifier]],
dest: Optional[StateIdentifier] = ...,
conditions: CallbacksArg = ..., unless: CallbacksArg = ...,
before: CallbacksArg = ..., after: CallbacksArg = ..., prepare: CallbacksArg = ...,
**kwargs: Dict[str, Any]) -> None: ...
def add_states(self, states: Union[Sequence[StateConfig], StateConfig],
on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: Optional[bool] = ..., **kwargs: Dict[str, Any]) -> None: ...
@staticmethod
def format_references(func: Callable) -> str: ...
def _convert_states_and_transitions(self, root: MarkupConfig) -> None: ...
def _convert_states(self, root: MarkupConfig) -> None: ...
def _convert_transitions(self, root: MarkupConfig) -> None: ...
def _add_markup_model(self, markup: MarkupConfig) -> None: ...
def _convert_models(self) -> List[Dict[str, str]]: ...
def _omit_auto_transitions(self, event: Event) -> bool: ...
def _is_auto_transition(self, event: Event) -> bool: ...
def _identify_callback(self, name: str) -> Tuple[Optional[str], Optional[str]]: ...
class HierarchicalMarkupMachine(MarkupMachine, HierarchicalMachine): # type: ignore
pass
def rep(func: Union[Callable, str, numbers.Number],
format_references: Optional[Callable] = ...) -> str: ...
def _convert(obj: object, attributes: List[str], format_references: Optional[Callable]) -> MarkupConfig: ...
transitions-0.9.0/transitions/extensions/diagrams_pygraphviz.py 0000644 0002322 0002322 00000023747 14304350474 025664 0 ustar debalance debalance """
transitions.extensions.diagrams
-------------------------------
Graphviz support for (nested) machines. This also includes partial views
of currently valid transitions.
"""
import logging
try:
import pygraphviz as pgv
except ImportError:
pgv = None
from .nesting import NestedState
from .diagrams_base import BaseGraph
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
class Graph(BaseGraph):
""" Graph creation for transitions.core.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):
self.fsm_graph = pgv.AGraph(**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)
def get_graph(self, title=None, roi_state=None):
if title:
self.fsm_graph.graph_attr['label'] = title
if roi_state:
filtered = _copy_agraph(self.fsm_graph)
kept_nodes = set()
active_state = roi_state.name if hasattr(roi_state, 'name') else roi_state
if not filtered.has_node(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
return self.fsm_graph
def set_node_style(self, state, style):
node = self.fsm_graph.get_node(state.name if hasattr(state, "name") else state)
style_attr = self.fsm_graph.style_attributes.get('node', {}).get(style)
node.attr.update(style_attr)
def set_previous_transition(self, src, dst):
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):
for state_name in self._get_state_names(state):
self._set_node_style(state_name, style)
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):
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 # pylint: disable=import-outside-toplevel; Only required for special cases
with TemporaryFile() as tmp:
if hasattr(tmp, "file"):
fhandle = tmp.file
else:
fhandle = tmp
graph.write(fhandle)
tmp.seek(0)
res = graph.__class__(filename=fhandle)
fhandle.close()
return res
transitions-0.9.0/transitions/extensions/markup.py 0000644 0002322 0002322 00000025521 14304350474 023101 0 ustar debalance debalance """
transitions.extensions.markup
-----------------------------
This module extends machines with markup functionality that can be used to retrieve the current machine
configuration as a dictionary. This is used as the foundation for diagram generation with Graphviz but can
also be used to store and transfer machines.
"""
from functools import partial
import importlib
import itertools
import numbers
from six import string_types, iteritems
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
# typing must be prevent redefinition issues with mypy
class Enum: # type:ignore
""" This is just an Enum stub for Python 2 and Python 3.3 and before without Enum support. """
class EnumMeta: # type:ignore
""" This is just an EnumMeta stub for Python 2 and Python 3.3 and before without Enum support. """
from ..core import Machine
from .nesting import HierarchicalMachine
class MarkupMachine(Machine):
""" Extends transitions.core.Machine with the capability to generate a dictionary representation of itself,
its events, states and models.
"""
# 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, model=Machine.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,
markup=None, auto_transitions_markup=False, **kwargs):
self._markup = markup or {}
self._auto_transitions_markup = auto_transitions_markup
self._needs_update = True
if self._markup:
# remove models from config to process them AFTER the base machine has been initialized
models = self._markup.pop('models', [])
super(MarkupMachine, self).__init__(model=None, **self._markup)
for mod in models:
self._add_markup_model(mod)
else:
super(MarkupMachine, self).__init__(
model=model, states=states, initial=initial, transitions=transitions,
send_event=send_event, auto_transitions=auto_transitions,
ordered_transitions=ordered_transitions, ignore_invalid_triggers=ignore_invalid_triggers,
before_state_change=before_state_change, after_state_change=after_state_change, name=name,
queued=queued, prepare_event=prepare_event, finalize_event=finalize_event,
model_attribute=model_attribute, on_exception=on_exception, **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):
""" Whether auto transitions should be included in the markup. """
return self._auto_transitions_markup
@auto_transitions_markup.setter
def auto_transitions_markup(self, value):
""" Whether auto transitions should be included in the markup. """
self._auto_transitions_markup = value
self._needs_update = True
@property
def markup(self):
""" Returns the machine's configuration as a markup dictionary.
Returns:
dict of machine configuration parameters.
"""
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):
""" Generates and returns all machine markup parameters except models.
Returns:
dict of machine configuration parameters.
"""
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):
""" Creates a string representation of referenced callbacks.
Returns:
str that represents a callback reference.
"""
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
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
class HierarchicalMarkupMachine(MarkupMachine, HierarchicalMachine):
""" Extends transitions.extensions.nesting.HierarchicalMachine with markup capabilities. """
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):
definition = {}
for key in attributes:
val = getattr(obj, key, False)
if not val:
continue
if isinstance(val, string_types):
definition[key] = val
else:
try:
definition[key] = [rep(v, format_references) for v in iter(val)]
except TypeError:
definition[key] = rep(val, format_references)
return definition
transitions-0.9.0/transitions/extensions/nesting.py 0000644 0002322 0002322 00000154465 14304350474 023263 0 ustar debalance debalance # -*- coding: utf-8 -*-
"""
transitions.extensions.nesting
------------------------------
Implements a hierarchical state machine based on transitions.core.Machine. Supports nested states, parallel states
and the composition of multiple hierarchical state machines.
"""
from collections import OrderedDict
import copy
from functools import partial, reduce
import inspect
import logging
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: # type: ignore
""" This is just an Enum stub for Python 2 and Python 3.3 and before without Enum support. """
class EnumMeta: # type: ignore
""" This is just an EnumMeta stub for Python 2 and Python 3.3 and before without Enum support. """
from six import string_types
from ..core import State, Machine, Transition, Event, listify, MachineError, EventData
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
# converts a hierarchical tree into a list of current states
def _build_state_list(state_tree, separator, prefix=None):
prefix = prefix or []
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]
def resolve_order(state_tree):
""" Converts a (model) state tree into a list of state paths. States are ordered in the way in which states
should be visited to process the event correctly (Breadth-first). This makes sure that ALL children are evaluated
before parents in parallel states.
Args:
state_tree (dict): A dictionary representation of the model's state.
Returns:
list of lists of str representing the order of states to be processed.
"""
queue = []
res = []
prefix = []
while True:
for state_name in reversed(list(state_tree.keys())):
scope = prefix + [state_name]
res.append(scope)
if state_tree[state_name]:
queue.append((scope, state_tree[state_name]))
if not queue:
break
prefix, state_tree = queue.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 (list of strings): 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, *args, **kwargs):
raise RuntimeError("NestedEvent.trigger must not be called directly. Call Machine.trigger_event instead.")
def trigger_nested(self, event_data):
""" Executes all transitions that match the current state,
halting as soon as one successfully completes.
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:
event_data (NestedEventData): The currently processed event
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
machine = event_data.machine
model = event_data.model
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()
event_data.event = self
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:
event_data.state = machine.get_state(state_name)
event_data.source_name = state_name
event_data.source_path = copy.copy(state_path)
self._process(event_data)
if event_data.result:
elems = state_path
while elems:
done.add(machine.state_cls.separator.join(elems))
elems.pop()
return event_data.result
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)
for trans in self.transitions[event_data.source_name]:
event_data.transition = trans
event_data.result = trans.execute(event_data)
if event_data.result:
break
class NestedEventData(EventData):
""" Collection of relevant data related to the ongoing nested transition attempt. """
def __init__(self, state, event, machine, model, args, kwargs):
super(NestedEventData, self).__init__(state, event, machine, model, args, kwargs)
self.source_path = None
self.source_name = None
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.
"""
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 state to add to the current state.
"""
for state in listify(states):
self.states[state.name] = state
def scoped_enter(self, event_data, scope=None):
""" Enters a state with the provided scope.
Args:
event_data (NestedEventData): The currently processed event.
scope (list(str)): Names of the state's parents starting with the top most parent.
"""
self._scope = scope or []
try:
self.enter(event_data)
finally:
self._scope = []
def scoped_exit(self, event_data, scope=None):
""" Exits a state with the provided scope.
Args:
event_data (NestedEventData): The currently processed event.
scope (list(str)): Names of the state's parents starting with the top most parent.
"""
self._scope = scope or []
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. """
def _resolve_transition(self, event_data):
dst_name_path = self.dest.split(event_data.machine.state_cls.separator)
_ = event_data.machine.get_state(dst_name_path)
state_tree = event_data.machine.build_state_tree(
listify(getattr(event_data.model, event_data.machine.model_attribute)),
event_data.machine.state_cls.separator)
scope = event_data.machine.get_global_name(join=False)
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
# when destination is empty this means we are already in the state we want to enter
# we deal with a reflexive transition here as internal transitions have been already dealt with
# the 'root' of src and dest will be set to the parent and dst (and src) substate will be set as destination
if not dst_name_path:
dst_name_path = [root.pop()]
scoped_tree = reduce(dict.get, scope + root, state_tree)
exit_partials = [partial(event_data.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 = []
queue = []
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:
queue.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 queue:
break
scoped_tree, prefix, initial_states = queue.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)
# Note: When conditions are handled like other dynamic callbacks the key == "conditions" clause can be removed
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 or key == "conditions":
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, model=Machine.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):
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
self._next_scope = None
super(HierarchicalMachine, self).__init__(
model=model, states=states, initial=initial, transitions=transitions,
send_event=send_event, auto_transitions=auto_transitions,
ordered_transitions=ordered_transitions, ignore_invalid_triggers=ignore_invalid_triggers,
before_state_change=before_state_change, after_state_change=after_state_change, name=name,
queued=queued, prepare_event=prepare_event, finalize_event=finalize_event, model_attribute=model_attribute,
on_exception=on_exception, **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 HierarchicalMachine): 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):
self._add_string_state(state, on_enter, on_exit, ignore, remap, **kwargs)
elif isinstance(state, Enum):
self._add_enum_state(state, on_enter, on_exit, ignore, remap, **kwargs)
elif isinstance(state, dict):
self._add_dict_state(state, ignore, remap, **kwargs)
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, HierarchicalMachine):
self._add_machine_states(state, remap)
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 and dest == self.wildcard_same:
source = self.get_nested_state_names()
else:
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):
""" Returns the name of the passed state in context of the current prefix/scope.
Args:
state (str, Enum or NestedState): The state to be analyzed.
join (bool): Whether this method should join the path elements or not
Returns:
str or list(str) of the global state name
"""
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):
""" Returns a list of global names of all states of a machine.
Returns:
list(str) of global state names.
"""
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):
""" Retrieves a list of all transitions matching the passed requirements.
Args:
trigger (str): If set, return only transitions related to this trigger.
src_path (list(str)): If set, return only transitions with this source state.
dest_path (list(str)): If set, return only transitions with this destination.
Returns:
list(NestedTransitions) of valid transitions.
"""
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):
""" Retrieves a list of valid triggers.
Args:
src_path (list(str)): A list representation of the source state's name.
Returns:
list(str) of valid trigger names.
"""
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.
Args:
state (str, Enum or list(str)): A state name, enum or state path
hint (list(str)): A state path to check for the state in question
Returns:
NestedState that belongs to the passed str (list) or Enum.
"""
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)
) # from KeyError
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):
""" Retrieves a list of NestedStates.
Args:
states (str, Enum or list of str or Enum): Names/values of the states to retrieve.
Returns:
list(NestedStates) belonging to the passed identifiers.
"""
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
Returns:
list(NestedTransitions): All transitions matching the request.
"""
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 _can_trigger(self, model, trigger, *args, **kwargs):
state_tree = self.build_state_tree(getattr(model, self.model_attribute), self.state_cls.separator)
ordered_states = resolve_order(state_tree)
for state_path in ordered_states:
with self():
return self._can_trigger_nested(model, trigger, state_path, *args, **kwargs)
def _can_trigger_nested(self, model, trigger, path, *args, **kwargs):
evt = NestedEventData(None, None, self, model, args, kwargs)
if trigger in self.events:
source_path = copy.copy(path)
while source_path:
state_name = self.state_cls.separator.join(source_path)
for transition in self.events[trigger].transitions.get(state_name, []):
try:
_ = self.get_state(transition.dest)
except ValueError:
continue
self.callbacks(self.prepare_event, evt)
self.callbacks(transition.prepare, evt)
if all(c.check(evt) for c in transition.conditions):
return True
source_path.pop(-1)
if path:
with self(path.pop(0)):
return self._can_trigger_nested(model, trigger, path, *args, **kwargs)
return False
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, model, allow_substates=False):
if allow_substates:
current = getattr(model, self.model_attribute)
current_name = self.state_cls.separator.join(self._get_enum_path(current))\
if isinstance(current, Enum) else current
state_name = self.state_cls.separator.join(self._get_enum_path(state))\
if isinstance(state, Enum) else state
return current_name.startswith(state_name)
return getattr(model, self.model_attribute) == state
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, state, model=None):
""" Set the current state.
Args:
state (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(state)]
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 = NestedEventData(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.
"""
event_data = NestedEventData(state=None, event=None, machine=self, model=model, args=args, kwargs=kwargs)
event_data.result = None
return self._process(partial(self._trigger_event, event_data, trigger))
def _trigger_event(self, event_data, trigger):
try:
with self():
res = self._trigger_event_nested(event_data, trigger, None)
event_data.result = self._check_event_result(res, event_data.model, trigger)
except Exception as err: # pylint: disable=broad-except; Exception will be handled elsewhere
event_data.error = err
if self.on_exception:
self.callbacks(self.on_exception, event_data)
else:
raise
finally:
try:
self.callbacks(self.finalize_event, event_data)
_LOGGER.debug("%sExecuted machine finalize callbacks", self.name)
except Exception as err: # pylint: disable=broad-except; Exception will be handled elsewhere
_LOGGER.error("%sWhile executing finalize callbacks a %s occurred: %s.",
self.name,
type(err).__name__,
str(err))
return event_data.result
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 a_state in self.states.values():
self._add_model_to_state(a_state, model)
def _add_dict_state(self, state, ignore_invalid_triggers, remap, **kwargs):
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_invalid_triggers
# 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 transitions:
self.add_transitions(transitions)
if remap is not None:
remapped_transitions.extend(self._remap_state(new_state, remap))
self.add_transitions(remapped_transitions)
def _add_enum_state(self, state, on_enter, on_exit, ignore_invalid_triggers, remap, **kwargs):
if remap is not None and state.name in remap:
return
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 state.name in self.states:
raise ValueError("State {0} cannot be added since it already exists.".format(state.name))
new_state = self._create_state(state, on_enter=on_enter, on_exit=on_exit,
ignore_invalid_triggers=ignore_invalid_triggers, **kwargs)
self.states[new_state.name] = new_state
self._init_state(new_state)
def _add_machine_states(self, state, remap):
new_states = [s for s in state.states.values() if remap is None or s not in remap]
self.add_states(new_states)
for evt in state.events.values():
self.events[evt.name] = evt
if self.scoped.initial is None:
self.scoped.initial = state.initial
def _add_string_state(self, state, on_enter, on_exit, ignore_invalid_triggers, remap, **kwargs):
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_invalid_triggers, **kwargs)
self.states[new_state.name] = new_state
self._init_state(new_state)
def _add_trigger_to_model(self, trigger, model):
trig_func = partial(self.trigger_event, model, trigger)
self._add_may_transition_func_for_trigger(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)
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)
def build_state_tree(self, model_states, separator, tree=None):
""" Converts a list of current states into a hierarchical state tree.
Args:
model_states (str or list(str)):
separator (str): The character used to separate state names
tree (OrderedDict): The current branch to use. If not passed, create a new tree.
Returns:
OrderedDict: A state tree dictionary
"""
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=None):
prefix = prefix or []
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
# if we reach this point without a prefix, we looped over all nested states
# and could not find a suitable enum state
if not prefix:
raise ValueError("Could not find path of {0}.".format(enum_state))
return None
def _get_state_path(self, state, prefix=None):
prefix = prefix or []
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
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 _remap_state(self, state, remap):
drop_event = []
remapped_transitions = []
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': 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 d_trans in drop_trans:
trans_source.remove(d_trans)
if not trans_source:
drop_source.append(source_name)
for d_source in drop_source:
del event.transitions[d_source]
if not event.transitions:
drop_event.append(trigger)
for d_event in drop_event:
del self.events[d_event]
return remapped_transitions
def _resolve_initial(self, models, state_name_path, prefix=None):
prefix = prefix or []
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]
a_state = self.get_state(state_name)
return a_state.value if isinstance(a_state.value, Enum) else state_name
def _trigger_event_nested(self, event_data, trigger, _state_tree):
model = event_data.model
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_nested(event_data, trigger, value)
if tmp is not None:
res[key] = tmp
if res.get(key, False) is False and trigger in self.events:
event_data.event = self.events[trigger]
tmp = event_data.event.trigger_nested(event_data)
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.9.0/transitions/extensions/diagrams_base.pyi 0000644 0002322 0002322 00000003016 14304350474 024527 0 ustar debalance debalance import abc
from typing import Protocol, Optional, Union, List, Dict, IO, Tuple, Generator
from .diagrams import GraphMachine, HierarchicalGraphMachine
from ..core import ModelState
class GraphProtocol(Protocol):
def draw(self, filename: Optional[Union[str, IO]], format:Optional[str] = ...,
prog: Optional[str] = ..., args:str = ...) -> Optional[str]: ...
class GraphModelProtocol(Protocol):
def get_graph(self, title: Optional[str]=None, force_new: bool=False, show_roi: bool=False) -> GraphProtocol: ...
class BaseGraph(metaclass=abc.ABCMeta):
machine: Union[GraphMachine, HierarchicalGraphMachine]
fsm_graph: Optional[GraphProtocol]
def __init__(self, machine: GraphMachine) -> None: ...
@abc.abstractmethod
def generate(self) -> None: ...
@abc.abstractmethod
def set_previous_transition(self, src: str, dst: str) -> None: ...
@abc.abstractmethod
def reset_styling(self) -> None: ...
@abc.abstractmethod
def set_node_style(self, state: ModelState, style: str) -> None: ...
@abc.abstractmethod
def get_graph(self, title: Optional[str] = ..., roi_state: Optional[str] = ...) -> GraphProtocol: ...
def _convert_state_attributes(self, state: Dict[str, str]) -> str: ...
def _get_state_names(self, state: ModelState) -> Generator[str, None, None]: ...
def _transition_label(self, tran: Dict[str, str]) -> str: ...
def _get_global_name(self, path: List[str]) -> str: ...
def _get_elements(self) -> Tuple[List[Dict[str, str]], List[Dict[str, str]]]: ... transitions-0.9.0/transitions/extensions/nesting.pyi 0000644 0002322 0002322 00000024550 14304350474 023423 0 ustar debalance debalance from ..core import Event, EventData, Machine, State, Transition, CallbacksArg, Callback, ModelParameter, TransitionConfig
from collections import defaultdict as defaultdict
from typing import OrderedDict, Sequence, Union, List, Dict, Optional, Type, Tuple, Callable, Any, Collection
from types import TracebackType
from logging import Logger
from enum import Enum
from functools import partial
_LOGGER: Logger
class FunctionWrapper:
_func: Optional[Callable]
def __init__(self, func: Callable, path: List[str]) -> None: ...
def add(self, func: Callable, path: List[str]) -> None: ...
def __call__(self, *args: List, **kwargs: Dict[str, Any]) -> Any: ...
class NestedEvent(Event):
def trigger_nested(self, event_data: NestedEventData) -> bool: ...
def _process(self, event_data: NestedEventData) -> bool: ... # type: ignore[override]
class NestedEventData(EventData):
state: Optional[NestedState]
event: Optional[NestedEvent]
machine: Optional[HierarchicalMachine]
transition: Optional[NestedTransition]
source_name: Optional[str]
source_path: Optional[List[str]]
class NestedState(State):
separator: str
initial: Optional[str]
events: Dict[str, NestedEvent]
states: OrderedDict[str, NestedState]
_scope: List[str]
def __init__(self, name: Union[str, Enum], on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: bool = ..., initial: Optional[str] = ...) -> None: ...
def add_substate(self, state: NestedState) -> None: ...
def add_substates(self, states: List[NestedState]) -> None: ...
def scoped_enter(self, event_data: NestedEventData, scope: List[str]=...) -> None: ...
def scoped_exit(self, event_data: NestedEventData, scope: List[str]=...) -> None: ...
@property
def name(self) -> str: ...
NestedStateIdentifier = Union[str, Enum, NestedState, Sequence[Union[str, Enum, NestedState, Sequence[Any]]]]
NestedStateConfig = Union[NestedStateIdentifier, Dict[str, Any], Collection[str], 'HierarchicalMachine']
# mypy does not support cyclic definitions, use Any instead of `StateTree`
StateTree = OrderedDict[str, Any]
def _build_state_list(state_tree: StateTree, separator: str,
prefix: Optional[List[str]] = ...) -> Union[str, List[str]]: ...
def resolve_order(state_tree: Dict[str, str]) -> List[List[str]]: ...
class NestedTransition(Transition):
def _resolve_transition(self, event_data: NestedEventData) -> Tuple[StateTree, List[partial], List[partial]]: ...
def _change_state(self, event_data: NestedEventData) -> None: ... # type: ignore[override]
def _enter_nested(self, root: List[str], dest: List[str], prefix_path: List[str],
event_data: NestedEventData) -> Tuple[StateTree, List[partial]]: ...
@staticmethod
def _update_model(event_data: NestedEventData, tree: StateTree) -> None: ...
def __deepcopy__(self, memo: Dict) -> NestedTransition: ...
ScopeTuple = Tuple[Union[NestedState, 'HierarchicalMachine'], OrderedDict[str, NestedState],
Dict[str, NestedEvent], List[str]]
class HierarchicalMachine(Machine):
state_cls: Type[NestedState]
transition_cls: Type[NestedTransition]
event_cls: Type[NestedEvent]
# mypy does not approve State being overridden with NestedState and Event with NestedEvent
states: OrderedDict[str, NestedState] # type: ignore
events: Dict[str, NestedEvent] # type:ignore
_stack: List[ScopeTuple]
_initial: Optional[str]
prefix_path: List[str]
scoped: Union[NestedState, HierarchicalMachine]
def __init__(self, model: Optional[ModelParameter]=...,
states: Optional[Union[Sequence[NestedStateConfig], Type[Enum]]] = ...,
initial: Optional[NestedStateIdentifier] = ...,
transitions: Optional[Union[TransitionConfig, Sequence[TransitionConfig]]] = ...,
send_event: bool = ..., auto_transitions: bool = ..., ordered_transitions: bool = ...,
ignore_invalid_triggers: Optional[bool] = ...,
before_state_change: CallbacksArg = ..., after_state_change: CallbacksArg = ...,
name: str = ..., queued: Union[bool, str] = ...,
prepare_event: CallbacksArg = ..., finalize_event: CallbacksArg = ...,
model_attribute: str = ..., on_exception: CallbacksArg = ..., **kwargs: Dict[str, Any]) -> None: ...
_next_scope: Optional[ScopeTuple]
def __call__(self, to_scope: Optional[Union[ScopeTuple, str, Enum]] = ...) -> HierarchicalMachine: ...
def __enter__(self) -> None: ...
def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
exc_tb: Optional[TracebackType]) -> None: ...
def add_model(self, model: ModelParameter, initial: Optional[NestedStateIdentifier] = ...) -> None: ... # type: ignore[override]
@property
def initial(self) -> Optional[str]: ...
@initial.setter
def initial(self, value: NestedStateIdentifier) -> None: ...
def add_ordered_transitions(self, states: Optional[Sequence[NestedState]] = ..., trigger: str = ..., loop: bool = ..., # type: ignore[override]
loop_includes_initial: bool = ..., conditions: CallbacksArg = ...,
unless: CallbacksArg = ..., before: CallbacksArg = ..., after: CallbacksArg = ...,
prepare: CallbacksArg = ..., **kwargs: Dict[str, Any]) -> None: ...
def add_states(self, states: Union[List[NestedStateConfig], NestedStateConfig], # type: ignore[override]
on_enter: CallbacksArg = ..., on_exit: CallbacksArg = ...,
ignore_invalid_triggers: Optional[bool] = ..., **kwargs: Dict[str, Any]) -> None: ...
def add_transition(self, trigger: str, # type: ignore[override]
source: Union[NestedStateIdentifier, List[NestedStateIdentifier]],
dest: Optional[NestedStateIdentifier] = ...,
conditions: CallbacksArg = ...,
unless: CallbacksArg = ..., before: CallbacksArg = ..., after: CallbacksArg = ...,
prepare: CallbacksArg = ..., **kwargs: Dict[str, Any]) -> None: ...
def get_global_name(self, state: NestedStateIdentifier = ..., join: bool = ...) -> Union[str, List[str]]: ...
def get_nested_state_names(self) -> List[str]: ...
def get_nested_transitions(self, trigger: str = ..., src_path: Optional[List[str]] = ...,
dest_path: Optional[List[str]] = ...) -> List[NestedTransition]: ...
def get_nested_triggers(self, src_path: Optional[List[str]] = ...) -> List[str]: ...
def get_state(self, state: Union[str, Enum, List[str]], hint: Optional[List[str]] = ...) -> NestedState: ...
def get_states(self, states: Union[str, Enum, List[Union[str, Enum]]]) -> List[NestedState]: ...
def get_transitions(self, trigger: str = ..., source: NestedStateIdentifier = ..., # type: ignore[override]
dest: NestedStateIdentifier = ..., delegate: bool = ...) -> List[NestedTransition]: ...
def get_triggers(self, *args: Union[str, Enum, State]) -> List[str]: ...
def has_trigger(self, trigger: str, state: Optional[NestedState] = ...) -> bool: ...
def is_state(self, state: Union[str, Enum], model: object, allow_substates: bool = ...) -> bool: ...
def on_enter(self, state_name: str, callback: Callback) -> None: ...
def on_exit(self, state_name: str, callback: Callback) -> None: ...
def set_state(self, state: Union[NestedStateIdentifier, List[NestedStateIdentifier]], # type: ignore[override]
model: Optional[object] = ...) -> None: ...
def to_state(self, model: object, state_name: str, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def trigger_event(self, model: object, trigger: str, *args: List, **kwargs: Dict[str, Any]) -> bool: ...
def _add_model_to_state(self, state: NestedState, model: object) -> None: ... # type: ignore[override]
def _add_dict_state(self, state: Dict[str, Any], ignore_invalid_triggers: bool, remap: Optional[Dict[str, str]],
**kwargs: Dict[str, Any]) -> None: ...
def _add_enum_state(self, state: Enum, on_enter: CallbacksArg, on_exit: CallbacksArg, ignore_invalid_triggers: bool,
remap: Optional[Dict[str, str]], **kwargs: Dict[str, Any]) -> None: ...
def _add_machine_states(self, state: HierarchicalMachine, remap: Optional[Dict[str, str]]) -> None: ...
def _add_string_state(self, state: str, on_enter: CallbacksArg, on_exit: CallbacksArg,
ignore_invalid_triggers: bool, remap: Optional[Dict[str, str]],
**kwargs: Dict[str, Any]) -> None: ...
def _add_trigger_to_model(self, trigger: str, model: object) -> None: ...
def build_state_tree(self, model_states: Union[str, Enum, Sequence[Union[str, Enum, Sequence[Any]]]],
separator: str, tree: Optional[StateTree] = ...) -> StateTree: ...
@classmethod
def _create_transition(cls, *args: List, **kwargs: Dict[str, Any]) -> NestedTransition: ...
@classmethod
def _create_event(cls, *args: List, **kwargs: Dict[str, Any]) -> NestedEvent: ...
@classmethod
def _create_state(cls, *args: List, **kwargs: Dict[str, Any]) -> NestedState: ...
def _get_enum_path(self, enum_state: Enum, prefix: Optional[List[str]] =...) -> List[str]: ...
def _get_state_path(self, state: NestedState, prefix: Optional[List[str]] = ...) -> List[str]: ...
def _check_event_result(self, res: bool, model: object, trigger: str) -> bool: ...
def _get_trigger(self, model: object, trigger_name: str, *args: List, **kwargs: Dict[str, Any]) -> bool: ...
def _has_state(self, state: NestedState, raise_error: bool = ...) -> bool: ... # type: ignore[override]
def _init_state(self, state: NestedState) -> None: ...
def _recursive_initial(self, value: NestedStateIdentifier) -> Union[str, List[str]]: ...
def _remap_state(self, state: NestedState, remap: Dict[str, str]) -> List[NestedTransition]: ...
def _resolve_initial(self, models: List[object], state_name_path: List[str],
prefix: Optional[List[str]] = ...) -> str: ...
def _set_state(self, state_name: Union[str, List[str]]) -> Union[str, Enum, List[Union[str, Enum]]]: ...
def _trigger_event(self, event_data: NestedEventData, trigger: str) -> Optional[bool]: ...
transitions-0.9.0/transitions/extensions/states.py 0000644 0002322 0002322 00000023166 14304350474 023110 0 ustar debalance debalance """
transitions.extensions.states
-----------------------------
This module contains mix ins which can be used to extend state functionality.
"""
from collections import Counter
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 keyword `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.") # from KeyError
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
class Retry(State):
""" The Retry mix-in sets a limit on the number of times a state may be
re-entered from itself.
The first time a state is entered it does not count as a retry. Thus with
`retries=3` the state can be entered four times before it fails.
When the retry limit is exceeded, the state is not entered and instead the
`on_failure` callback is invoked on the model. For example,
Retry(retries=3, on_failure='to_failed')
transitions the model directly to the 'failed' state, if the machine has
automatic transitions enabled (the default).
Attributes:
retries (int): Number of retries to allow before failing.
on_failure (str): Function to invoke on the model when the retry limit
is exceeded.
"""
def __init__(self, *args, **kwargs):
"""
Args:
**kwargs: If kwargs contains `retries`, then limit the number of times
the state may be re-entered from itself. The argument `on_failure`,
which is the function to invoke on the model when the retry limit
is exceeded, must also be provided.
"""
self.retries = kwargs.pop('retries', 0)
self.on_failure = kwargs.pop('on_failure', None)
self.retry_counts = Counter()
if self.retries > 0 and self.on_failure is None:
raise AttributeError("Retry state requires 'on_failure' when "
"'retries' is set.")
super(Retry, self).__init__(*args, **kwargs)
def enter(self, event_data):
k = id(event_data.model)
# If we are entering from a different state, then this is our first try;
# reset the retry counter.
if event_data.transition.source != self.name:
_LOGGER.debug('%sRetry limit for state %s reset (came from %s)',
event_data.machine.name, self.name,
event_data.transition.source)
self.retry_counts[k] = 0
# If we have tried too many times, invoke our failure callback instead
if self.retry_counts[k] > self.retries > 0:
_LOGGER.info('%sRetry count for state %s exceeded limit (%i)',
event_data.machine.name, self.name, self.retries)
event_data.machine.callback(self.on_failure, event_data)
return
# Otherwise, increment the retry count and continue per normal
_LOGGER.debug('%sRetry count for state %s is now %i',
event_data.machine.name, self.name, self.retry_counts[k])
self.retry_counts.update((k,))
super(Retry, self).enter(event_data)
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. """
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."""
transitions-0.9.0/transitions/extensions/factory.pyi 0000644 0002322 0002322 00000004652 14304350474 023424 0 ustar debalance debalance from ..core import Machine, State
from .diagrams import GraphMachine, NestedGraphTransition, HierarchicalGraphMachine
from .locking import LockedMachine
from .nesting import HierarchicalMachine, NestedEvent
from typing import Type, Dict, Tuple, Callable, Union
try:
from transitions.extensions.asyncio import AsyncMachine, AsyncTransition
from transitions.extensions.asyncio import HierarchicalAsyncMachine, NestedAsyncTransition
except (ImportError, SyntaxError):
# Mocks for Python version 3.6 and earlier
class AsyncMachine: # type: ignore
pass
class AsyncTransition: # type: ignore
pass
class HierarchicalAsyncMachine: # type: ignore
pass
class NestedAsyncTransition: # type: ignore
pass
class MachineFactory:
@staticmethod
def get_predefined(graph: bool = ..., nested: bool = ...,
locked: bool = ..., asyncio: bool = ...) -> Union[
Type[Machine], Type[HierarchicalMachine], Type[AsyncMachine], Type[HierarchicalAsyncMachine],
Type[GraphMachine], Type[HierarchicalGraphMachine], Type[AsyncGraphMachine],
Type[HierarchicalAsyncGraphMachine], Type[LockedMachine], Type[LockedHierarchicalMachine],
Type[LockedGraphMachine], Type[LockedHierarchicalGraphMachine]
]: ...
class LockedHierarchicalMachine(LockedMachine, HierarchicalMachine): # type: ignore[misc]
# replaces LockedEvent with NestedEvent; method overridden by LockedEvent is not used in HSMs
event_cls: Type[NestedEvent] # type: ignore
def _get_qualified_state_name(self, state: State) -> str: ...
class LockedGraphMachine(GraphMachine, LockedMachine): # type: ignore
@staticmethod
def format_references(func: Callable) -> str: ...
class LockedHierarchicalGraphMachine(GraphMachine, LockedHierarchicalMachine): # type: ignore
transition_cls: Type[NestedGraphTransition]
event_cls: Type[NestedEvent]
@staticmethod
def format_references(func: Callable) -> str: ...
class AsyncGraphMachine(GraphMachine, AsyncMachine):
# AsyncTransition already considers graph models when necessary
transition_cls: Type[AsyncTransition] # type: ignore
class HierarchicalAsyncGraphMachine(GraphMachine, HierarchicalAsyncMachine): # type: ignore
# AsyncTransition already considers graph models when necessary
transition_cls: Type[NestedAsyncTransition] # type: ignore
_CLASS_MAP: Dict[Tuple[bool, bool, bool, bool], Type[Machine]]
transitions-0.9.0/transitions/extensions/locking.py 0000644 0002322 0002322 00000017771 14304350474 023240 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())
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:
""" 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:
""" Manages the identity of threads to detect whether the current thread already has a lock. """
def __init__(self):
self.current = 0
def __enter__(self):
self.current = get_ident()
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, model=Machine.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,
machine_context=None, **kwargs):
self._ident = IdentManager()
self.machine_context = listify(machine_context) or [PicklableLock()]
self.machine_context.append(self._ident)
self.model_context_map = defaultdict(list)
super(LockedMachine, self).__init__(
model=model, states=states, initial=initial, transitions=transitions,
send_event=send_event, auto_transitions=auto_transitions,
ordered_transitions=ordered_transitions, ignore_invalid_triggers=ignore_invalid_triggers,
before_state_change=before_state_change, after_state_change=after_state_change, name=name,
queued=queued, prepare_event=prepare_event, finalize_event=finalize_event,
model_attribute=model_attribute, on_exception=on_exception, **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 []
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)
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
def _get_qualified_state_name(self, 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.9.0/transitions/extensions/asyncio.py 0000644 0002322 0002322 00000076772 14304350474 023265 0 ustar debalance debalance """
transitions.extensions.asyncio
------------------------------
This module contains machine, state and event implementations for asynchronous callback processing.
`AsyncMachine` and `HierarchicalAsyncMachine` use `asyncio` for concurrency. The extension `transitions-anyio`
found at https://github.com/pytransitions/transitions-anyio illustrates how they can be extended to
make use of other concurrency libraries.
The module also contains the state mixin `AsyncTimeout` to asynchronously trigger timeout-related callbacks.
"""
# Overriding base methods of states, transitions and machines with async variants is not considered good practise.
# However, the alternative would mean to either increase the complexity of the base classes or copy code fragments
# and thus increase code complexity and reduce maintainability. If you know a better solution, please file an issue.
# pylint: disable=invalid-overridden-method
import logging
import asyncio
import contextvars
import inspect
from collections import 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. """
async def enter(self, event_data):
""" Triggered when a state is entered.
Args:
event_data: (AsyncEventData): The currently processed event.
"""
_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.
Args:
event_data: (AsyncEventData): The currently processed event.
"""
_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):
""" A state that allows substates. Callback execution is done asynchronously. """
async def scoped_enter(self, event_data, scope=None):
self._scope = scope or []
await self.enter(event_data)
self._scope = []
async def scoped_exit(self, event_data, scope=None):
self._scope = scope or []
await self.exit(event_data)
self._scope = []
class AsyncCondition(Condition):
""" A helper class to await condition checks in the intended way. """
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. """
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 (EventData): 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):
""" Representation of an asynchronous transition managed by a ``HierarchicalMachine`` instance. """
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 AsyncEventData(EventData):
""" A redefinition of the base EventData intended to easy type checking. """
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, EventData(None, self, self.machine, model, args=args, kwargs=kwargs))
return await self.machine.process_context(func, model)
async def _trigger(self, event_data):
event_data.state = self.machine.get_state(getattr(event_data.model, self.machine.model_attribute))
try:
if self._is_valid_source(event_data.state):
await self._process(event_data)
except Exception as err: # pylint: disable=broad-except; Exception will be handled elsewhere
_LOGGER.error("%sException was raised while processing the trigger: %s", self.machine.name, 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
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)
for trans in self.transitions[event_data.state.name]:
event_data.transition = trans
event_data.result = await trans.execute(event_data)
if event_data.result:
break
class NestedAsyncEvent(NestedEvent):
""" A collection of transitions assigned to the same trigger.
This Event requires a (subclass of) `HierarchicalAsyncMachine`.
"""
async def trigger_nested(self, event_data):
""" 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:
event_data (AsyncEventData): The currently processed event.
Returns: boolean indicating whether or not a transition was
successfully executed (True if successful, False if not).
"""
machine = event_data.machine
model = event_data.model
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()
event_data.event = self
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:
event_data.state = machine.get_state(state_name)
event_data.source_name = state_name
event_data.source_path = copy.copy(state_path)
await self._process(event_data)
if event_data.result:
elems = state_path
while elems:
done.add(machine.state_cls.separator.join(elems))
elems.pop()
return event_data.result
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)
for trans in self.transitions[event_data.source_name]:
event_data.transition = trans
event_data.result = await trans.execute(event_data)
if event_data.result:
break
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 or str): 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, model=Machine.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):
self._transition_queue_dict = {}
super().__init__(model=model, states=states, initial=initial, transitions=transitions,
send_event=send_event, auto_transitions=auto_transitions,
ordered_transitions=ordered_transitions, ignore_invalid_triggers=ignore_invalid_triggers,
before_state_change=before_state_change, after_state_change=after_state_change, name=name,
queued=queued, prepare_event=prepare_event, finalize_event=finalize_event,
model_attribute=model_attribute, on_exception=on_exception, **kwargs)
if self.has_queue is True:
# _DictionaryMock sets and returns ONE internal value and ignores the passed key
self._transition_queue_dict = _DictionaryMock(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):
""" 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:
callables (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
if 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 (partial): 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_async(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_async(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].model not in models]
self._transition_queue.clear()
self._transition_queue.extend(new_queue)
async def _can_trigger(self, model, trigger, *args, **kwargs):
evt = AsyncEventData(None, None, self, model, args, kwargs)
state = self.get_model_state(model).name
for trigger_name in self.get_triggers(state):
if trigger_name != trigger:
continue
for transition in self.events[trigger_name].transitions[state]:
try:
_ = self.get_state(transition.dest)
except ValueError:
continue
await self.callbacks(self.prepare_event, evt)
await self.callbacks(transition.prepare, evt)
if all(await self.await_all([partial(c.check, evt) for c in transition.conditions])):
return True
return False
def _process(self, trigger):
raise RuntimeError("AsyncMachine should not call `Machine._process`. Use `Machine._process_async` instead.")
async def _process_async(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()
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):
""" Asynchronous variant of transitions.extensions.nesting.HierarchicalMachine.
An asynchronous hierarchical machine REQUIRES AsyncNestedStates, AsyncNestedEvent and AsyncNestedTransitions
(or any subclass of it) to operate.
"""
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.
"""
event_data = AsyncEventData(state=None, event=None, machine=self, model=model, args=args, kwargs=kwargs)
event_data.result = None
return await self.process_context(partial(self._trigger_event, event_data, trigger), model)
async def _trigger_event(self, event_data, trigger):
try:
with self():
res = await self._trigger_event_nested(event_data, trigger, None)
event_data.result = self._check_event_result(res, event_data.model, trigger)
except Exception as err: # pylint: disable=broad-except; Exception will be handled elsewhere
event_data.error = err
if self.on_exception:
await self.callbacks(self.on_exception, event_data)
else:
raise
finally:
try:
await self.callbacks(self.finalize_event, event_data)
_LOGGER.debug("%sExecuted machine finalize callbacks", self.name)
except Exception as err: # pylint: disable=broad-except; Exception will be handled elsewhere
_LOGGER.error("%sWhile executing finalize callbacks a %s occurred: %s.",
self.name,
type(err).__name__,
str(err))
return event_data.result
async def _trigger_event_nested(self, event_data, _trigger, _state_tree):
model = event_data.model
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_nested(event_data, _trigger, value)
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_nested(event_data)
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())
async def _can_trigger(self, model, trigger, *args, **kwargs):
state_tree = self.build_state_tree(getattr(model, self.model_attribute), self.state_cls.separator)
ordered_states = resolve_order(state_tree)
for state_path in ordered_states:
with self():
return await self._can_trigger_nested(model, trigger, state_path, *args, **kwargs)
async def _can_trigger_nested(self, model, trigger, path, *args, **kwargs):
evt = AsyncEventData(None, None, self, model, args, kwargs)
if trigger in self.events:
source_path = copy.copy(path)
while source_path:
state_name = self.state_cls.separator.join(source_path)
for transition in self.events[trigger].transitions.get(state_name, []):
try:
_ = self.get_state(transition.dest)
except ValueError:
continue
await self.callbacks(self.prepare_event, evt)
await self.callbacks(transition.prepare, evt)
if all(await self.await_all([partial(c.check, evt) for c in transition.conditions])):
return True
source_path.pop(-1)
if path:
with self(path.pop(0)):
return await self._can_trigger_nested(model, trigger, path, *args, **kwargs)
return False
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.") from None
else:
self.on_timeout = kwargs.pop("on_timeout", None)
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 __init__(self, item):
super().__init__()
self._value = item
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.9.0/transitions/extensions/states.pyi 0000644 0002322 0002322 00000002572 14304350474 023257 0 ustar debalance debalance from ..core import State, EventData, Callback
from logging import Logger
from threading import Timer
from typing import List, Union, Any, Dict, Optional, Type
_LOGGER: Logger
class Tags(State):
tags: Logger
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def __getattr__(self, item: str) -> Any: ...
class Error(Tags):
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def enter(self, event_data: EventData) -> None: ...
class Timeout(State):
dynamic_methods: List[str]
timeout: float
_on_timeout: Optional[List[Callback]]
runner: Dict[int, Timer]
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def enter(self, event_data: EventData) -> None: ...
def exit(self, event_data: EventData) -> None: ...
def _process_timeout(self, event_data: EventData) -> None: ...
@property
def on_timeout(self) -> List[Callback]: ...
@on_timeout.setter
def on_timeout(self, value: Union[Callback, List[Callback]]) -> None: ...
class Volatile(State):
volatile_cls: Any
volatile_hook: str
initialized: bool
def __init__(self, *args: List, **kwargs: Dict[str, Any]) -> None: ...
def enter(self, event_data: EventData) -> None: ...
def exit(self, event_data: EventData) -> None: ...
def add_state_features(*args: Type) -> Any: ...
class VolatileObject: ...
transitions-0.9.0/transitions/extensions/diagrams_graphviz.py 0000644 0002322 0002322 00000026202 14304350474 025300 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
try:
import graphviz as pgv
except ImportError:
pgv = None
from .diagrams_base import BaseGraph
_LOGGER = logging.getLogger(__name__)
_LOGGER.addHandler(logging.NullHandler())
class Graph(BaseGraph):
""" Graph creation for transitions.core.Machine.
Attributes:
custom_styles (dict): A dictionary of styles for the current graph
"""
def __init__(self, machine):
self.custom_styles = {}
self.reset_styling()
super(Graph, self).__init__(machine)
def set_previous_transition(self, src, dst):
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.name if hasattr(state, "name") else 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):
""" Triggers the generation of a graph. With graphviz backend, this does nothing since graph trees need to be
build from scratch with the configured styles.
"""
if not pgv: # pragma: no cover
raise Exception("AGraph diagram requires graphviz")
# we cannot really generate a graph in advance with graphviz
def get_graph(self, title=None, roi_state=None):
title = title if title else self.machine.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
# pylint: disable=redefined-builtin,unused-argument
def draw(self, 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 (str): 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."
) # from None
filename.write(graph.pipe(format))
return None
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_node_style(self, state, style):
for state_name in self._get_state_names(state):
super(NestedGraph, self).set_node_style(state_name, style)
def set_previous_transition(self, src, dst):
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)
def _add_nodes(self, states, container):
self._add_nested_nodes(states, container, prefix="", default_style="default")
def _add_nested_nodes(self, states, container, prefix, default_style):
for state in states:
name = prefix + state["name"]
label = self._convert_state_attributes(state)
if state.get("children", []):
cluster_name = "cluster_" + name
attr = {"label": label, "rank": "source"}
attr.update(
**self.machine.style_attributes["graph"][
self.custom_styles["node"][name] or default_style
]
)
with container.subgraph(name=cluster_name, graph_attr=attr) as sub:
self._cluster_states.append(name)
is_parallel = isinstance(state.get("initial", ""), list)
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="0.0" if is_parallel else "0.1",
)
self._add_nested_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):
edges_attr = defaultdict(lambda: defaultdict(dict))
for transition in transitions:
# enable customizable labels
src = transition["source"]
try:
dst = 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.9.0/transitions/version.pyi 0000644 0002322 0002322 00000000021 14304350474 021225 0 ustar debalance debalance __version__: str
transitions-0.9.0/setup.py 0000644 0002322 0002322 00000004226 14304350474 016165 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': ['py.typed', '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.9.0/conftest.py 0000644 0002322 0002322 00000001123 14304350474 016643 0 ustar debalance debalance """
pytest configuration - Tests async functionality only when asyncio and contextvars are available (Python 3.7+)
"""
# imports are required to check whether the modules are available
# pylint: disable=unused-import
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):
""" Text collection function executed by pytest"""
if not WITH_ASYNC and basename(str(path)) in async_files:
return True
return False
transitions-0.9.0/mypy.ini 0000644 0002322 0002322 00000000572 14304350474 016152 0 ustar debalance debalance [mypy]
disallow_untyped_defs = True
disallow_any_unimported = True
no_implicit_optional = True
check_untyped_defs = True
warn_return_any = True
warn_unused_ignores = True
show_error_codes = True
ignore_missing_imports = False
[mypy-pygraphviz.*]
ignore_missing_imports = True
[mypy-graphviz.*]
ignore_missing_imports = True
[mypy-pycodestyle.*]
ignore_missing_imports = True
transitions-0.9.0/examples/ 0000755 0002322 0002322 00000000000 14304350474 016265 5 ustar debalance debalance transitions-0.9.0/examples/Graph MIxin Demo.ipynb 0000644 0002322 0002322 00002712274 14304350474 022262 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": "iVBORw0KGgoAAAANSUhEUgAABOgAAACnCAIAAAAkHPQUAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeTzU+f8A8PcY5jAYV3J0OIpyLEUklIrtIrIpFW1boS1HqU1bqTaErUSl+1fbXapNomyrKETFbgcloVxDCGNcw4z5/fH+7mdnHWMwzND7+UePmfd8jvfnM5PPvOb9/rxeOA6HAxAEQRAEQRAEQRBEVIkJuwMIgiAIgiAIgiAIwgsKXBEEQRAEQRAEQRCRhgJXBEEQBEEQBEEQRKSJC7sDCDLE1NTU5OTk1NbWMplMYfcFEIlEOTk5PT09eXl5YfcFQRAEQRAEQQYKClwRhC85OTlnz56Ni4vLy8sTdl+6oK2tbW9v/8MPP+jp6Qm7LwiCIAiCIAgiYGiqMIL0ID8/38HBQV9fPzY21tHR8f79+6WlpS0tLRwR0NLSUlpaev/+fUdHxzt37ujr6zs4OOTn5wv7nCEIgiAIgiCIIOE4qBwOgnSjpaXll19+OXTo0Pjx43/99de5c+ficDhhd6pbHA4nISFh69atHz582LRp0+7du0kkkrA7hSAIgiAIgiACgAJXBOlaZWWlo6Pju3fvAgMD161bJy4+NObVs1isEydOBAQETJw4MSYmRklJSdg9QhAEQRAEQZD+QoErgnQhJyfHzs5OXFz87t27EyZMEHZ3ei03N9fe3p7FYsXFxaG7XhEEQRAEQZChDgWuCNJRSUmJmZmZlpZWTEyMgoKCsLvTR1++fHF0dCwoKHj27Nno0aOF3R0EQRAEQRAE6TsUuCLIfzQ1NVlbWzc0NDx9+lRWVlbY3ekXBoNhYWGBx+NTUlKkpKSE3R0EQRAEQRAE6SOUVRhB/mPt2rVFRUX37t0b6lErAEBaWjo2NpZGo3l4eAi7LwiCIAiCIAjSd2jEFUH+lZycPHPmzPj4+Pnz5wu7LwJz7969BQsWJCUlWVtbC7svCIIgCIIgCNIXKHBFkP9hs9mTJ08eO3ZsbGyssPsiYPb29h8/fnz58uVQyY2MIAiCIAiCINzQVGEE+Z+rV6++e/fu4MGDwu6I4IWHh+fl5V27dk3YHUEQBEEQBEGQvkAjrgjyP5aWlqqqqtHR0cLuyIBYsmRJeXl5SkqKsDuCIAiCIAiCIL2GRlwRBAAAKioq0tPT3dzchN2RgeLq6vr06dPPnz8LuyMIgiAIgiAI0msocEUQAABITk7G4/GzZ88WdkcGio2NDR6PT05OFnZHEARBEARBEKTXUOCKIAAA8Pr1ax0dHUlJSWF3ZKBISkrq6Oi8efNG2B1BEARBEARBkF5DgSuCAABAeXn56NGjeS9z4MABHA6Hw+FGjRo1OL3i7dq1a7A/JBKJn+VHjRpVXl4+0L1CEARBEAT5ejx79iwgIMDGxkZVVZVMJuOQ7snIyIwfP37x4sXHjh0rLS3t7alGyZkQBAAAli5d2t7efuPGjR6XNDIyqq6uxv6zNTQ0TJo0SUdHJy4uTrBd4nPLNjY2qampLS0tPW7Q2dlZTEzs+vXrgusjgiAIgiDI14jD4Vy+fDk0NDQnJ0dDQ2PmzJn6+vqKiop8Did8nerr68vKyv76669Hjx41NTXZ2dnt3bv3m2++4XN1VNQRQQAAgMPh4HC4vq3Y3t7e3t4+EF0S7JZxOPRDFYIgCIIgSH9lZWX5+Pg8e/bMzc3t/PnzxsbGwu7RENPa2nrnzp0DBw5MnjzZ09MzMDBQXl6+x7XQVGEE6RdpaemCgoJ79+4NoS0jCIIgCIIgfRMaGmpqaiouLp6ZmXnu3DkUtfYBgUBwdnbOyMj4v//7v9u3b+vq6qanp/e4FgpcEQRBEARBEARBetDa2vrDDz/s3Lnz0KFDycnJRkZGwu7R0IbD4b7//vvc3FxTU9NZs2ZdvXqV9/IocEWQvouJicFuN+e+yzQ3N9fR0ZFKpUpKSpqamsbFxdnY2MDF1q5dGxQUBB9bWlrC5RMSEmCLoqIin1umUChWVlapqamDebwIgiAIgiBfJzabvWjRot9///3u3bs+Pj59u8UM6UxGRub27dvr169fsWLF6dOneSyJ7nFFkL5zdHTkcDiOjo537tzBGvPz883NzSkUys2bN83NzYuKijZu3Pj69WsikYiFoDt37pSSksJWmTt3LofDMTEx+fTpE/9b/vjx45YtWwoKCgbjUBEEQRAEQb5imzZtSk5OTk5OnjJlirD7Mtzg8fiDBw9KS0tv2LBBU1Nz9uzZXS6GRlwRRMC2b99eV1cXGRlpa2srJSWlp6d35cqVxsZGgW/ZwMDg3LlzqMINgiAIgiDIgDpx4kRUVNT58+f7FrWKWklF0bR79+7Fixc7Ozvn5+d3uQAKXBFEwBISEgAAc+bMwVpGjBgxYcKEgdiyqqqqtrZ2/7eMIIJ16dIlbK479+QC0dG37xBdFk/etm0bdrBTp04dgM4iCIIgwkSj0X766aft27cvXry4b1vYsmULh8MxNDQUbMeGGRwOd/bs2bFjx3p5eXW5AApcEUSQmEwmg8EgkUgdvqzLyckN0JaVlJT6uWUEGSDHjx/ncDgNDQ3waUNDw/jx4+3s7ITbK6jL7xA99tDFxYXD4XSYwhQaGsrhcDgcDh6PH6juIgiCIMKzdetWJSWlHTt2CLsjwx+JRIqKinrw4EFsbGznV9E9rggiSEQiUVpamsFgNDQ0cEeYlZWVHZYUExNrbW3lbqmrq+vDlmtqagTRcQQBAAApKSkjI6MBSvo1cEWPBUX0e9jZs2fP4uLi0tPT3759W1tby53LDelAWlp65MiRhoaGs2bNWrhwIZqwhyAIP168eHHlypVbt25xz7VBBs60adOWLVu2efPmBQsWdPhFGAWuCCJg8+bNi46OTkhIwOaTVFRU5OXldVhMRUWlrKwMe1pRUVFcXCwjI9OrLVdXV79//16g3UeQgQJLEwu7F7yIfg8xHA7n8uXLoaGhOTk5GhoaM2fOXLBggaKiIvpexUN9fX1ZWdlff/21bds2Hx8fOzu7vXv3fvPNN8LuF4IgIu3IkSOTJk1atGiRsDvyFfnll1+0tbXv3btnb2//nxc4CIJwOM7Ozs7OzvwsaWhoqKamxt3i4OAAAGhuboZP8/Pz5eXl1dTUHjx4wGAw3rx5M3fu3LFjxxKJRO614PT9I0eOMBiM/Pz8JUuWqKmpKSgo8L/lnJycOXPmKCkpddgyj2P87rvv+FkS+WpRKBQLC4v+b+fixYvgn6nCoqzzf2d+zJ49u8v/dHg83szMTBD96kFmZua0adPwePyqVasyMzMHYY/DDJPJjI6ONjU1xePx69ev//Lli7B7hCCIiGpubqZQKMeOHeOxzP79+2FUpaam9vz581mzZklJSZHJZGtr69TUVO4lO1x02trarl27ZmNjM3LkSBKJpK+vHxERwWazsQVaWloCAgJ0dHTIZLKcnJydnd2dO3dYLBaHw7l9+zYWzX369GnJkiVSUlLy8vKurq41NTUfP360s7OTkpJSVlZeu3ZtfX09/zsVETNnzly2bFmHRhS4IsMWm82OjIxMSEj4+PFjj/8h+QlcsT9M0I4dO7j/agAAVqxYAZd8//69o6OjjIyMpKTktGnTHj9+3Pmbbl1d3dq1a1VUVMhksqWl5YsXL4yNjeF2/P39e9wymUyeMmVKXFwcdrvdmjVrejxGKSkpEomkqalpY2Pj4eGxe/fukydP/vnnn9nZ2dx/1JAuVVZWent7jx07VkJCQlFRcdGiRX///TeHw6mtreV+swIDAzkcTltbG9YCfy/gfang/7JXXV29adMmTU1NCQkJWVnZuXPnPnr0CL7E/bHJzc11dnaWl5eHT6uqqvjsAAaPx/d47N3pHLhy9w37LYbHJZkHgZxwiPs7RJc95HA47969c3BwgP+dLS0tU1JShBu4hoSEiImJTZ8+nfdbgPSovb39t99+U1FRGTly5NOnT4XdHQRBRNGDBw8AACUlJT0uaWhoSKFQzM3Nnz592tDQ8OLFi2+++YZAICQnJ3Mvwx243r17FwCwb9++mpqaqqqqw4cPi4mJwRQM0Nq1a6lU6oMHD5qamioqKrZs2QIASEpKwhaAIxxOTk6ZmZkNDQ0XLlwAAMybN8/BweHvv/9mMBgnTpwAAGzatIn/nYqI8PBwOTm59vZ27kYUuCLD2ZgxY+DXUAKBMGHCBGdn54CAgMuXL2dmZnaI0/gfce2b7r7pDiZnZ2crK6vDhw/7+/uvWLHCyspKQ0ODQCBgX9aVlJQmT568cOFCLy+vkJCQixcvPn78uKCgoKWlRbg9FwU0Gm3s2LEjR46Mj49nMBjZ2dkzZswgkUjY9925c+eKiYnl5+dzr2Vubn7lyhX4mJ9LRY+XvfLycg0NjZEjR969e5dOp79//97JyQmHw50+fRrbCLyMzZgxIykpqbGxMSMjA4/HV1VV8dOBLkdcezz2zrobce0wiaDHSzIPgjrhvCdQfPjwQVZWFpvm8Pr162+//VZdXV0ogSuTyVy1ahUej4+MjOxwLUf6jE6n29vbk0gk7JODIAiCCQkJGT16ND9Lwmx/3D8pvn79GgBgaGjIvUyHwNXa2pp7I66urhISEnQ6HT7V0NCYNm0a9wLa2tqdA9f4+HisRU9PDwDw+PFjrEVDQ0NHR4f/nYqI9PR0AEBhYSF3IwpckeHM0dFRTOzf1NliYmISEhI4HA4+HTFihJWV1fr16w8fPjx9+vQFCxYM3HdBEQlcuwzOa2pqsrOz//zzz5MnT+7evdvDw8PGxkZXV1dSUhI7dXJycrq6up3HaRsaGgb/QITi+++/BwBcvnwZaykvLycSicbGxvBpYmIiAGD9+vXYAqmpqWPGjGlra4NP+blU9HjZW7VqFQDg6tWr2AItLS2qqqpkMrmiogK2wMvYvXv3OhwCPx3oMnDt8dg74zNw7fGSzIOgTjjvwNXZ2RkAcPPmTWyBsrIyIpE4+IEri8WaP3++jIxM53cW6ScWi+Xn54fD4U6dOiXsviAIIlo8PT1nzZrFz5Lwp+cOjaqqqgAAGo2GLcP7/hQ4+wn7XfjHH38EALi7u6enp3c5HQlesz5//oy12NraAgAaGxuxFktLS2lpaf53KiKqq6sBAA8fPuRuRIErMpz98ssv3COKXRIX/1+KMkVFxVevXg1QT0Q5cOWhpqYmMzMzNjb25MmT/v7+bm5uNjY2cJIq75i2oKCgtbV1gA5EKKhUqpiYWIffIydPnsw9g2jSpEmSkpLV1dXwqYODQ3h4OI9tdr5U9HjZo1KpAIAO8wXc3NwAAOfPn8f2CwDAutGrDnQZuPJz7B3wGbj2eEnmTSAnnHfgKi0tDQBgMBjcyxgYGAx+4Ort7S0pKfn8+fMB2j6ye/duCQmJxMREYXcEQRAR4uLismjRIn6W7DIoNTIyAgC8fPmyy2Xq6uoCAgL09fVlZWW5v5pif4ja29svXLgwe/ZsSUlJSUnJOXPm/P7779zb73DN4nA4c+bM4b7Th8PhzJgxg/urRY87FRHwDqBbt25xN6KswshwZmho2KHkTGccDkdVVVVdXV1ZWXkg0kteu3Zt2bJl8DEOh1uzZs2ZM2cEvhd+sFgsIpHYq1Xk5OSMjY2xm2+51dbWFhYW0mi08vJy+KCwsDAxMbG4uJjFYmGra2pqqqioqKqqcj8YM2YM9nvBkMBkMul0OgAAxo0dfPjwAdbV2Lx5s6ur67FjxwICAvLy8p48eQLjN4hOpx88ePD27dulpaXcpY+ampq4t9bhQgIAUFJSotFolZWV8vLydDqdRCLBaAozcuRIAEBFRQV3I4VC6bAdPjvQt2Pvm6ioKHNz8/Pnz8Nbta2srDw9PfnP3CiQE84Dj+LJnfOED6gTJ05ERUVdv359ypQpg7nfr8ru3bvz8vKcnZ2fP38+btw4YXcHQRCRwGaz+f/GAjO9YTP7wD/VEJWUlLpc3t7ePiUlJTIyctmyZYqKijgcLiIiAt6PChfA4XBubm5ubm5tbW3JyckHDhxwcnI6ePCgn59fn4+ox52KCHjasa+UkFg3CyOi5cCBAzgcDofDobpz/GhoaHj69Onx48ejo6N5LCYhIUEkEnfu3Jmfn29gYAC/nQuci4sL929FwopaAQB0Or1zUNRnMKa1t7f38PAIDQ29cOECHGhta2vDxmlDQ0NtbGzk5OQKCwtPnTq1Zs0aW1tbLS0tCQkJeXl5ExMTe3t7T0/PsLCwCxcuJCYmFhYWdvgLJSKIRKKsrKy4uDg2DZXbzJkz4WJLly4dPXr00aNHmUzmwYMH3d3duSNMe3v7wMBAd3f3vLw8OCn90KFDAIAOlwp42eNuwS57RCKRSqW2tLQwGAzuBT5//gwAUFZW5n0U/HSA+3Lbq2PvG3hJTkxMrKuri4mJ4XA4Tk5O4eHhfK4ukBPOAyye3NLS0tDQwN0+yMWTaTTaTz/9tH37dqwOFjIQcDjc2bNnx44dC1O+IwiC9FZLS8uLFy+wp2/evKHRaIaGhioqKp0XZrPZaWlpysrKPj4+I0aMgNff5uZm7mVkZWVzc3MBABISEra2tjExMTgcLj4+vs895GenogwFrkMDTCgC739DOispKYmLiwsODnZ2dtbW1qZSqRYWFj///HNJSUmXVQ3FxcVxONzChQvz8vL27NlDJpM1NDSGfUHU9+/fa2pqDsKO+I9pyWRyTk7OqVOnVq9e3WNMy2azB6Hz3XFycmKxWGlpadyNYWFhY8aMwYJtcXFxX1/fysrKgwcPXrt2zcfHB1uS/0sF78seHI3kvmgxmcyHDx+SyeQ5c+bw6D+fHZCUlMQmKejo6Jw6dYrPY++bfl6SBXLCeZs3bx4AICEhAWsZ/OLJW7duVVJS2rFjx2Du9OtEIpGioqIePHgQGxsr7L4gCDL0UKnU7du3p6enNzY2ZmZmurq6EgiEyMjILhfG4/HW1tYVFRX79++vrq5ubm5OSkqCSYC5rVu37vXr10wms7Ky8tdff+VwOLNmzepzD/ncqejq7wRkZBB1nj0vqKKLQ0tbW1t2dnZ0dPTu3bvt7OzgPEkAgIqKip2dnb+///nz57Ozs2HdCwsLC+4PPBy4NjIySktL497mn3/+CfhLdz5ElZSUAAD+/PNPYXeka62trWVlZZmZmdHR0REREf7+/s7OzhYWFpqamng8Hnv7YEjs7Ozs4+MTGhoaHR2dkpJSUFDQh9sje+vz589aWlqampr37t2rq6v78uXLiRMnJCUlr1+/zr1YfX09lUrF4XArV67ssAV4pfn111+rqqqampoePXoEs15zvymGhoZUKnX27Nn8ZBWur6/HsgpzJ5XpfMcL/x2YO3culUotLi5++vSpuLj427dv+T92bnze40qlUmfMmPHq1auWlpbPnz/v2bMHABAUFMTzrfiP/p/wXpVl5l08eSDucX3+/DkOh+twUxMyoJYvXz5u3LhB+KuCIIjo4z8/CLygvH37ds6cOdLS0mQyecaMGVhBu84lFTkcTlVVlaen5+jRoyUkJEaOHLlq1apt27bBBWD6w5cvX3p6ek6cOFFSUlJeXn7q1KmnT5+Gc4hg0l3uDXL/6g0ACAkJSUlJ4W7ZvXs3PzsVHQCADt80UOA6lHy1gWtdXV1KSkpERISHh4eFhQWZTAYASEhI6Orqurm5hYaGxsbGVlZWdrmur68vlp9JXFxcSUnp/PnznbMH81NgekiLioqiUChDsbANk8nsLqbFUkYTCAQVFZUuY1oB1tT+8uWLn58fzE01YsSIb7/9tssfAn766ScAQOdEX/xcKnhf9qDq6uqNGzdqaGhISEhQqdQ5c+ZgOfc6XMY6/DTJTwdyc3OtrKwoFMro0aOjoqJ6e+wY3nVcwT+liXlckvnXtxPeh7LMPRZPHojA1c3NbfLkyYLdJsLbhw8fcDhcbGyssDuCIIjw9TZwHej+fFU6B644jojdiYvwYGRkVF1dXVpairVISUkZGRmlpqYKsVcDgUajZWVlZWVlvX37Nicn5927dxwOR1ZWVk9PD+YK0tPT09fX5yfV0Llz59auXYvH48XExH7++eeffvqJu8oLt5UrV+bk5GRlZQn6aETC5MmTDQwMzp8/L+yOCFJra2t1dTWWHYr7wadPn9rb2wEABAJBQUGhQ3Yo+EBdXZ27WpIo6Px/fIi6dOmSm5vb8ePH161bJ+y+DB5xcXETE5OMjAxBbbClpUVRUXH//v0w/TIPubm527ZtS0pKamtr09fX37VrV0RExMOHDwEAMCEci8W6devWmTNn3rx5Q6fTx40bt3btWm9vb+y/AJPJDA4Ojo6OLi4uJpFIFhYW7u7uCxYs4J7y8PWYNWuWsrLylStXhN0RBEGEbMmSJQAA3jlToGFzBRcdOBzu+vXr8C2AhlJizyEhJiYGS4n56dOnrVu33rt3j0AgzJ8///Dhw3Q63dvbOzk5WUpKys7OLjw8nDuVSFVVVWBgYGxsLI1Go1KpVlZWu3btgnm0Oztw4AAcZ0hLS4O3b+HxeNFMbNOj1tbWDx8+YJHq33///eXLFwAANoYGI9W+3Z8JC2AuXrz4119/5Z3aytvb28zM7Pbt2/wnNR0qbt++/fLly5MnTwq7IwJGIBBUVVVVVVU75z1mMplfvnyBoSwWzaalpdFoNFjvFHQT08LHysrKohbTIl+hlJSUxsZGe3t73ovl5+ebm5tTKJSbN2+am5sXFRVt3Ljx9evXRCKxpaUFLpOQkODi4rJv377o6Gg2m3316tWNGzeWlpZiI89eXl43bty4ceOGpaVlfX39gQMHHBwckpKSrK2tB/QYRRPM7MX5b3ZQBEEQRMiEMO77FYB3STk5OWVmZjY0NFy4cAEAMG/ePAcHh7///pvBYMDboGHuaYhGo40dO3bkyJHx8fEMBiM7O3vGjBkkEol3ycEhOlW4pqYGTv11c3PT1dWFv+hLSUkZGxu7ublFRESkpKQ0NDQIZF8tLS3p6el8Luzq6qqpqdn55sAhraWlZfz48W5ubsLuiKhoaWkpKChISUmJjo4ODQ318fGBP46oqKhgX1KJRKKmpqaFhYWzs7O/v39ERER0dHRmZmZZWVlvJ7L2yrCZaMRdlqZzZdphxt/fHztYwU4VDgkJGT16dI+LOTs7AwBu3ryJtVRWVkpKSnLfiHv37l1ra2vutVxdXSUkJLDyvBoaGtOmTeNeQFtbOykpqT/9H7rgrPvCwkJhdwRBECHjZ6pwl/evIv0H0FThweHo6Hjnzp34+Pj58+fDFn19/ZycnMePH0+fPh22aGpqEggEmFETALBq1arz589fvnx5+fLlsKWiokJdXV1fXz8zMxO2DNGpwiwWq7i4GM7ChcrLywEAKioqenp6urq6cPbvxIkThT7GRaPRdHR0Nm7cGBgYKNyeCFBAQEBERMT79+9VVVWF3RdR19LSQqPROsw6xh7AZYhEopqaWufitCoqKtyhb29hcyigHTt2BAUFCeCQhiweZ3L37t0wjdOwt27dug8fPsAZvzzIyMgwGAwGg8Fdb9bY2DgnJwcbce0MfuSePn1qbm4OAFi/fv3x48fd3d1Xr149ZcqUr3OGMObLly+KiooPHz7sT/ZOBEGGAf6nCiMCJ4ipwqWlIDYWPHoEXr0Cnz+D/5YTFCEkEpCTA3p6YOpUYGcHzMwGvwsmJibYY1VV1ZycHO4WNTW1V69eYU9jYmLExMTs7OywFmVlZT09vaysrNLS0qFVvrW+vv7169fw9tSsrKy///67qalJXFxcW1tbT0/Pw8PD2NjY1NQUywYsOlRVVffv379hwwZDQ8PhUTLx5s2b+/bti4qKQlErP0gkEpwt3PmlLmNaWKentrYWW11VVbXLmLbH879ly5YtW7YI/pCGLPSjKgCATqdTqVTeyzCZTAaDQSKRuKNWAICcnFyHTR08ePD27dulpaV1dXVYe1NTE3wQFRVlbm5+/vx5mHrKysrK09Nz+N03wSd42rlPFIIgCCJ0vQlcX78Gu3aBuDggKQlmzQJubkBNDcjIDFjf+qelBVRXg+xscPkyCAoCenpg2zawYgUYxPtVZLhOjpiYGB6P504LhMfjYfIYAACTyaTT6eCfi2UHHz58EPHAFeZSwiLV3Nzc9vZ2KpWqr69vbGy8cuVKOKwKswGLuHXr1r19+/b7778fO3bslClThN2dfnnx4sX333+/YcOGrypBzgDhEdM2Nzd3HqFNTEwsKCjAvvjCmLZzNKulpSUrKzu4h4IMGWw2W1y8h8s0kUiUlpZmMBgNDQ3csWtlZSX3Yvb29ikpKZGRkcuWLVNUVMThcBEREfB2FbgADodzc3Nzc3Nra2tLTk4+cOCAk5PTwYMH/fz8BH5cog+e9iGaNgJBEGS44i9wrakBAQHg5ElgbAyuXgUODuCf+iJDQ1YWOHoUrFoFjh8Hhw+DTnlchI5IJMrKyjY0NDQ3N/f4NYWbUPJGtLW15eXlYZHqs2fPqqqqAFcuJTgBWFdXd4imtTh06FBBQYGNjc21a9fmzZsn7O700f37911cXKytrQ8dOiTsvgxzZDK5VzHt27dv8/Pz4W9VoPuYdty4cT2OtiEIAGDevHnR0dEJCQnYPJGKioq8vDxsATabnZaWpqys7OPjgzU2Nzdzb0RWVjYjI2PChAkSEhK2traWlpYUCiU+Pv7rDFwRBEEQEcRHjJSeDhYtAmJi4P/+D6xcOZgjlgJjbAzOnQO+vsDXF5iaguBg8E81P9Hh5OR09uzZtLS0GTNmYI1hYWFRUVGFhYXdRbOSkpKtra3wsY6OzubNmz08PATet7q6uuzsbCzrb3Z2NpPJJBAI48aNMzY23rFjh56e3qRJkxQUFAS+a6HA4/G3b9/29PS0t7cPDw/39vYeWhE4h8M5cuSIn5+fm5vbyZMnv/J71YSrDzHthw8f6uvr4TLdxbTjx4+XEdnZLsig27dvX2Ji4saNG6lUqrm5+adPn3766SdlZeWKigq4AB6Pt7a2fvTo0f79+3/44c5xkxEAACAASURBVAcKhZKRkQFzBHJbt27d4cOHdXR06HQ6rMGL7vBEEAQRNUMiwc0A6SlwvXoVrF4NbG3BpUuiOyuYT0ZGIDkZHDkC/PzA+/fg5EmRGjcOCQl5/Pjx6tWrjx49Om3aNDabfePGjb179547d47HGOzkyZPT09NLSkpKS0sLCwutrKwE0hmsjCqMVAsLCwEAcnJyurq6FhYWPj4+xsbGEyZMGMYREYFAOHfunI6OzqZNm27duhUZGdldXSJR8/LlS19f39TU1ODg4G2i9wMNguEnpuUOa7OyskpKShj/pBXoHNPCx2PGjOEusoV8DbS0tNLT0/39/RcvXsxisYyMjEJCQnbv3g3nwkDXr1/fuXPnkSNHduzYIS8vP2/evOXLl4eGhtra2hobG2dmZj5+/Pj48eMuLi5FRUUkEklbW/v06dNr1qwR4nEhCIIgCDeegevp08DTE2zaBH79FfAIUVpaQGoqyMoCHz+Cujrwz32bg01aGowcCQwNgbU16C7rDw4HfHzA+PHAxQVUVoLYWF7H1ScZGRkwQyMAgEwm79ixw9HREbtVEofDhYSEWFpaYhEmDoeDGTKVlJSeP38eHBzs5eVVUlIiKys7adKkO3fu2NjYgP9mHMXhcFjG0YiICHd394kTJ8rLy0dGRk6cOLEPfWYwGHl5eVjW35cvXzY2NoqLi48ZM0ZXV9fNzc3Y2HjKlCnKysr9PDlDzrZt22xtbX18fExMTNzc3DZs2MCdXkvUZGZmRkVFXbx40czM7Pnz551LmyJDBY+Ytra2tnPS46ysrOLi4oaGBriMnJxclwmixo4d2yF/DzJsaGtr3759m7ulvLxcUVERe6qoqNh5iDUkJAR7bGho2HkBBEEQBBEd3ZfDefgQzJsHtm8HPKoOvHgBDh8Gv98CTc3tinJsRbl2MkFYc4lxrW14eiO+vBK0c4CZGVi/Hri4gO7GKl+8ANbWYM0acPjw4HZTJMAZiVikCnMpycjIGBgYYPVpJk+ezJ1K6mvG4XAuX74cGhqak5Ojrq4+c+ZMAwMDRUVFEokk7K6B5ubm6urq7OzspKSkT58+6evr+/v7r1ixYmjNbUYEosuYlkajFRUVNTY2wmW6i2nV1dUpFIpw+490xmcZhoqKCl1d3c+fP0tISMCWT58+jR8/3tXV9dy5cwPey2GqcxkGBEG+QoIth1NVVRUYGBgbG0uj0ahUqpWV1a5du+CcvpiYGCyR+8ePH/39/f/44w88Hm9ubh4ZGamlpQU6Vc4DAODxeCyNHJ8bz83NDQgIePjwYU1NDVyL+1dOkdL573A3gWt+PjA1BXPngsuXuw5EaTSwdSu4coU1VrV5qgHzm/HtsiIxOQ3X2kZ4/4n0PIf46j3Q0QFHo4C1ddeL3rwJli4FUVFguCdcZbFY79+/xyLV58+fw2yTMJcSFqmKQhlVEff8+fO7d+9mZGTk5OTU1tbyKJA4aEgkkpycnJ6e3tSpU+3t7U1NTYXdI0QUdRnTFhYWlpSUtLW1wWW6i2k1NDTQb1jCwn/gqqKi8sMPP/zyyy8KCgrZ2dne3t75+fkvXrzoctwe4QcKXBEEAQINXMvLy83NzVtaWs6ePTt9+vSioqINGzY8e/bs0aNH2GxNR0fHO3fuODg4+Pv7f/PNN+np6QsXLtTX13/+/Dm2nS7vceV/4zNmzNizZ4+pqembN28sLCwqKioUFRVnzZr16tWr+Pj4qVOn9v9IBYXvOq5eXmDsWHD2bNdR64kTYMtmNoXc4O7ENNIZmK72EYcgwTQYzzQYj6+skf79EWHmTODiAk6fBp0nyC1eDLZvBz/9BBYuBMOrxCWdTn/z5g13fZqWlhYJCYnx48cbGxv7+fnp6uqam5uL7O8rIsvU1BRFhshQJCcnB3/g6PxSbW1thxHawsLCxMTE4uJi7EdcOTm5zgmiNDU1R48ejQ3xIUKkrKycmJgYFRU1ffp0Go0mJydnY2Nz5coVFLUiCIKIjp9//rmoqOjy5cvz588HAOjp6V27dk1dXd3b2zszM5N7ybVr18Jo08bGZsGCBTdv3qyurub9vZ3/jfv7+1tbWwMAzMzMsAt9e3s7h8MR/QrqXQWud+6ABw9AcjLoPBOSzQabNoGjRxvnWTTNmcaR6E0Z2MHFVpKvW7eYkF0gczkeZzENFxcPRo/uuNDOneD6deDvDy5eFEYfBQbLpQQj1Xfv3nE4HJhLydjY2MPDQ09PT19fn0gkCrunCIKIFjk5OWNj4y7viO5PTDtmzJheVfZC+mn27NmzZ88Wdi8QBEG+RtnZ2QYGBtjTDRs2HD16tPNiMTExYmJidnZ2WIuysrKenl5WVlZpaemoUaOwdiw5DgBg9OjRAAAajcY7cOV/412OwSQnJ/M8RFHR6YsFmw22bAHLloHp0zu+1NoKHB04jx7Vr13EnDRhcPrXT636WrVbVsqevImfYgIePgIdBhyIRBAWBr77Dvj4AK6PiIhrbW398OEDFqn+9ddfcJI6VkYVTgBGv7UjCNIfKKZFEARBkB7p6+v3OFbJZDJh/fYuK7R/+PCBO7bkXoZAIAAA2nnmvu3Vxod0SotO3x7i40FBAbh/v4tlPTw4jx/X+S5vUx9KE2vZCtQaP1fZ4zfE58/DvcgESkr/eXnRIjBpEjh6FJw/L6QO9qy2thZLpJSVlfX+/Xs2my0tLa2tra2rq7tr1y5jY+NJkyYN6Q8igiBDSI8xLXdYm5OTk5iYWFRUxGazsdW7jGnHjh07jItsIchQdOnSJTc3N/iYQqFg2ctFB5auRk1NrbS0lM+1rl27tmzZMgAAkUjkJ2PFs2fPgoKCsrKyGhoa9PX1ly5d6ubmJi8v35+eD4S+nQ0hEuDbt23btrCwMPjYzMwsIyNjAPrbd0QiUVZWtqGhobm5uZ+/3nZOwCnAjYu4Tsl4rl4FM2eCceM6toeEgIsX67+3H1pRK8QhEeke37W3NoN580BTU8eX164Ft24BJlMYXesCi8XKycm5cePGnj177O3tVVRU5OXlrayswsLCysvLbWxszp49m52dXVdXl5mZeeHCBV9fX0tLSxS1IggiCmBM6+zs7OvrGxoaGh0dnZqaWlBQ0NzcXFZWlpmZGR0dvXv3bhsbGzKZnJOTc+rUqdWrV9va2mppaZHJZFVVVRMTkyVLlvj6+oaFhd24cSM1NbWwsBALehFhaWhoGD9+PPc8NIR/A3T2Bu1NOX78OIfDwaJWkfowbNmyhcPhGBoacjf22EMXFxcOh8PnBPu0tDRLS8v29va0tLTy8nJfX19/f/+tW7fy2cPBPF1dng1RJsC3LzQ0FN6lKbI/gDo5ObFYrLS0NO7GsLCwMWPGYJOV+CEpKdna2gof6+jonDp1SoAbF3H/Dco5HPDHH2DXro5LZWWBnTsZ381mGnQKaIeIdgq5zuM7+YMXcYGBgKtyHQAA2NuD9etBSgqwsRFK3+rr61+/fo0lUvrrr7/g7yXa2tp6enqenp7GxsZmZmZKHcaKEQRBhg4JCQlVVVVVVdXO47Stra3V1dWdi9PGxcV9+vQJzo8iEAgKCgqdkx6rqqqqq6ujjOiDgMPhtLe3d5iu1mVyS6SzLs+eyG5WZPfLP8H28MyZMywWKyIiQkNDAwCwdOnSJ0+eMPke8BD90yVqhusZCwkJefz48erVq48ePTpt2jQ2m33jxo29e/eeO3euV8OkkydPTk9PLykpKS0tLSwstLKy6v/GRTOrcGf/PZLCQlBbC/5Jmvw/HA7w9W3TGt1sPWTuAu0SW1mhYYGl9MGD4IcfgLb2vy+MGgVGjQJ//TVogSvMpYRFqjCXEpVK1dfXNzY2Xrlypa6uromJiSiUCUUQBBloBAKhVzFtWloajUb7/PkzimkHk7S0dEFBgbB7MVQN0NkT1psi+h8GwfYQ3r5YUVExfvx42BIVFSWsznwNhusZU1JSev78eXBwsJeXV0lJiays7KRJk+7cuWNjYwMAyMjIwOrWkMnkHTt2BAUFYbOCJ02atGDBgri4OABARESEu7v7xIkT5eXlIyMjJ06c2NuNg38+1RgWizUEswp//AgA6DhP+PJlkJ7O2PYD6KoyztDSPH2y5NPXeD8/EBf3nxe0tf937AOgra0tLy8Py6X08uXL6upqwJVLCVZS1dXV7TxnHUEQ5GvGI6ZlMpllZWUd6tPCmLaiogJefYlEory8PAxlO4S1KioqQvyTW19fLyMjI6y9IwjSK05OTufPn/f29k5NTZXqXF4RQfgmLy9/8ODBgwcPdn5p6tSpnePGLiNJHR2dJ0+e9H/j3LrcoAj670/R9fUAAPDfhFScfcEtZgasUSMHsVcDRkyMsXAGiI8HOTn/aadSQV2doHZSW1ubmpoaGRm5cuVKExMTaWlpfX19d3f3xMREFRWVnTt3pqSkMBgMGo129+7dPXv2wNgVRa0IgiD8IxKJmpqalpaWzs7O/v7+kZGR0dHRmZmZNBqtubm5oKAgJSXl4sWLvr6+FhYWAIDExMSwsLClS5eamJioqamRyWQtLS1LS8slS5Zs27YtMjLyxo0bWVlZNBptEH5yDg8PNzU1jYuLG8yft6uqqnx8fNTV1QkEwogRI5ycnF6+fAlfsrS0xP3D1dUVAGBjY4O11NXVxcTEYE9hKpQDBw7gcLjGxsa0tDTYPrwzgvRH57MHffnyxc/PT0tLi0AgyMnJzZs3LykpqfMqnz59Wrp0qaysrIKCgp2dHTYS1eVmZWVlcZ2IiYlhaW94fAz6czhMJnPXrl0TJkyQlJSUl5e3t7ePjY3t8db0uro67n4GBQUBAFgsFtayePFi2HL9+nVbW1tlZWUymWxgYBAZGcljHml3Jzw3N9fR0ZFKpVIoFCsrK/6nuGtpacnIyLx69WrhwoX8ZHLqsTN9O11Qb88GP7vj8VHkYai8fchw8t/AFd68y33tefYM9y63aUYXqSOHqFY9LfZIRXDu3H9axcVBXzN/sNnswsJCGILa29traWnBXEq//PJLYWGhhYXFqVOnsrOzm5qacnJysFxK6Bc7BEGQAcIjpm1qasJiWg8PDziQC2PaJUuWwJhWUlKyu5hWUD0sKSnJzMy0t7fX19ePjo4ehFu5ysvLp0yZEh0dfezYsZqamuTk5JqaGnNz8/T0dABAamrqy5cvKRSKoaHhyZMnAQDx8fFmZmZXr17lcDiysrKOjo4cDsfBwQHbIEypQqFQLCws4AQz7vwfs2bNUlBQELWsnsLS+ewBACoqKqZMmXLlypXIyMjq6upnz55JSkrOnj37zJkzHVbZuHHjxo0by8rKrl+//ujRI5hMtbvNAgAYDAbnH3v37gUABAcHw2IYvD8G/TkcLy+vw4cPHzly5MuXL+/evZswYYKDg0NKSgrvTcnKynI4nLlz54qJieXn5+/cuRMAIC4uzuFwzM3Nr1y5cvPmTQBAQkKCi4vLrFmz3r17V1JS4uHh4efn5+/v36se5ufnm5ubZ2Zm3rx58/Pnz8eOHQsMDORnPmpSUpKpqenevXsdHBySkpKcnZ2xj7qdnV2HIG1ATxfU27PR4+54fxR5GBJvHzLM9PT7aFxcu5ICa4zyoHRmUOAA85txkndiwIEDfdsAg8HIy8vD6tO8fPmysbERy6Xk5uZmbGw8ZcoUZeVhdNIQBEGGBRKJBKcNd36ppaUFFqTlnn6cmJhYUFBQ98+UHBKJpKqq2rmQj6amppycHP/dKCwshGOtubm5Li4uo0aN2rx587p164hEokAOs7Off/65qKjo8uXL8+fPBwDo6eldu3ZNXV3d29s7MzMTAGBoaHju3LklS5asXLny5s2bnp6es2fPdnFx6dvu2tvbh8TtUkL0888/f/z48erVqzB1qoyMzJUrVzQ1NX18fOzt7UeO/Hea29q1a+HNaTY2NgsWLLh582Z1dbWiomKPu4AZvFetWvXzzz9jO+X9Meizhw8f6unp2draAgDIZPL+/ftjY2P5XHfLli0JCQnh4eHYjaNpaWllZWXOzs7YMtbW1thReHt7P3/+PDIyMiAggP8p99u3b6+rqztz5gzspIGBwblz53qseF9dXb1o0SIrKytfX99169bNnz8/Li7Ozc3t8uXLYmJicXFxHz9+1NPTYzAYvcpk25/TBXp/Nnjvjv+PYpdE+e1Dhp+eAte0tFatUT0sM9S06qhL/pkBamoAfwW4aDQalkgpKysrNze3vb1dRkbGwMBAT0/P2dkZ1jOE9zojCIIgQxGPmLa5ublDgigY0+bn58Oa7+CfmLZzgigtLS1ZWdkOGywqKoIP4FhraWmpn59fWFiYv7+/h4dHr64m2dnZBgYG2NMNGzYcPXq082IxMTFiYmLc5SWUlZX19PSysrJKS0vhcJyzs/OOHTuCg4MtLS3l5eXPnj3Lfzc6SE5O7vO6X4nbt28DABYsWIC1EInE2bNnX7x48Y8//li5ciXWPmXKv6kxR48eDQCg0WjdBa7YjyzPnj37/vvvp0+fDofQIX4+Bn0zd+7c48ePe3h4rF69esqUKXg8/v3793yuO3v27EmTJv3222979+5VUFAAAOzfv3/jxo3Y5HM7O7sOlVEMDQ0vXbqUk5Nj3iGfaPcSEhIAAHPmzMFaVFVVtbW18/LyeKx17tw5Op2+YsUKAACRSLxz587s2bOvXbsmLS0Na5AkJydbWlr2tv5Kf05XH84G793x/1Hskii/fcjw00Pgynn3lmWhPzhdGTQs1REAAJCbC6ZN6+JVFuv9+/dY1t/nz59XVlaCf3Ip2dvb+/v7Gxsbo1xK/OCnrvSQK5bdne6qtEdHRy9dupRAIPCfOv/r8fVUHkeGNDKZ3F1MW1tbW1ZWVlRUVFpaWlZWVlxcXFpa+vz58+Li4ubmZriMrKzsqFGjxowZM2rUKDU1tbFjx3aYdQwHJ8vLyzdv3vzLL7/4+Phs2rSJ+t98E93R19fvcWCTyWTCALvLbX748AGLWAIDAxMTE58+fXr+/HmUkHngwHeERCJJS0tzt8PRrYqKCu5G7neNQCCAf37v4KG4uNjBwWH06NG///47XAX05mPQB1FRUebm5ufPn4elNa2srDw9PRctWsTn6ps3b3Z1dT127FhAQEBeXt6TJ08uXryIvUqn0w8ePHj79u3S0tI6rowkTU1NfG6fyWQyGAwSidThRi0lJSXekQ98FRt1lJKSun///owZM06fPi0tLf3rr79GRkZu376dz25g+nO6+nA2eOyuVx/F7ojs24cMPz1clnA1te3SlEHox7HEZyPX7xu5fp/R9iP8rxWT+RauNdonjP+1OFKSAABQXc3dGJWfv3LlSkNDQ0lJSX19fU9Pz4cPHyorKwcEBDx58qSurg7mUgoNDV25ciXKpcQnfgph9632tMjqUKUdADBixAjsX8zQPUDB+qoqjyPDkpycnL6+/oIFCzw9Pffu3fvbb78lJibm5uY2NTXB+2n//PPPyMhIV1fXUaNG0Wi02NhYLy+v7n7GYrPZtbW1QUFBqqqq27Ztw0rM9xORSJSVlRUXF29ra+N0MnPmTGzJ5ORkOp1uYGCwfv36V69e9bhldCnsGyKRSKVSW1paGAwGd/vnz58BAP281YjBYNjZ2bW1tcXFxclzzSzj/2PQBzgczs3NLTExEaby4nA4Tk5O4eHhfK6+dOnS0aNHHz16lMlkHjx40N3dnTuOsre3DwwMdHd3z8vLg7PQDx06BLpJuNolIpEoLS3d0tLCfXUGANTU1PBeEQ4hvnv3DmuRl5d/8OCBpqZmeHi4ubk5hULhnhPLp/6crj6cDR67E8hHUWTfvq8NzJmHw+H68yOUiOvp99TWVs6gfAtcb2P2+dh2vVFK3I2NzNapu4+7Hovubi1HE93Px7Zb6aj3al8ccTwAAPw3L9y9iorPnz/PnTv3t99+y87OZjAYL168OH36tJeXl5WVFZ+/fCOCMpi1p6WkpCwtLQdu+10GrqJZXHugTwWfRPPkIEhvwXFaGxublStX+vv7nzx58u7du5mZmU+fPuW9IpvNbmpqCgsLi4uLe/PmDfwG2U9OTk4sFistLY27MSwsbMyYMVimmY8fP65Zs+bWrVuxsbFkMtnBwaGqqor3ZiUlJbHoWkdHB06eRPgBx7vi4+OxFiaT+fDhQzKZzD0fsrfYbLaLi0tubu6tW7e0/ylZv3jx4piYGMDfx6BvZGVlc3NzAQASEhK2trYwMSz30fEmLi7u6+tbWVl58ODBa9eu+fj4cB9RWlqasrKyj4/PiBEj4G8l2HQG/s2bNw/8M+MUqq6u7nGCLnybDh06VFtbizWqqKgkJibKysq+ePEC5t/ubWf6fLr6djZ4767/H0WRfftE39SpUwU4hsHPcNFQJ9ITgTgc0M7htA9Kdod4S8s//vgjLCxs+fLlenp6KK2/cMHa0/fu3RN2RwSgy8B1OB2gwKGTgwxvvGfFS0hIwDm6ioqKysrKJBJJIIFrSEiIlpbW6tWr79+/T6fTa2pqTp48uXfv3gMHDsDrXUNDg6OjY0REhK6urrq6+s2bN2k02uLFi9va2nhsdvLkyXl5eSUlJenp6YWFhVZWVrAdZRXuUUhIiIaGxsaNG+Pi4mDSx+XLl5eXl0dGRvaYDoeHTZs23bt379SpU9bW1l3ulPfHoD/WrVv3+vVrJpNZWVn566+/cjicWbNm8b+6h4cHlUrduXOno6Ojmpoa1o7H462trSsqKvbv319dXd3c3JyUlHTixInedm/fvn3y8vIbN278888/Gxoa3r596+rq2mOJBzMzs23bthUVFVlaWt67d6+xsbGpqSktLW3r1q0UCkVOTi4wMPD8+fO97Qzo6+nq89ngsTuBfBRF8+1D+k9EhjQwIh24SpEIz/euv7JhqbA7giB9p6ioiMPhOgSuCIJ8tYqLizsECfAuRDExMS0tLRcXl+PHj2dnZ1dVVU2bNm38+PHffPNN/3eqpKT0/PlzR0dHLy+vESNGTJgw4ffff79z586SJUsAAF5eXtLS0q9fv3ZwcMjOzq6urra2tm5ra3vy5AmBQAgKCoJDNHfu3AEAkMlkWOsVABAREfHNN99MnDhx6dKlkZGREydOhO0sFgtlFcZ0efaUlZVfvHixbNkyHx8fBQUFU1PTxsbGxMREd3d3AEBGRgb3KrDQCA6Hg3fyT5o0yc7OrvNms7Kyjhw5AgD44YcfuAts3rp1C/aE98egP4fz+PHjCRMmuLi4yMvLT5w4MSEh4fTp0726+VNaWtrDw4PD4WzevLnDS9evX/f09Dxy5IiqqqqGhsaFCxeWL18OALC1tTUxMYHTI1+9elVWVobD4Xbu3NllD7W0tNLT06dMmbJ48WIlJaVVq1Z5e3sbGBgwmUwcDrd27druOhYSEhIXF6eurv7999/Lysqqqan5+/ubm5vn5ubGx8eTyeRVq1bB89zlqLXAT1dvz0aPu+P9UeSTyL593Wlqajpx4sSXL196uyIiXLj/XFeio8HSpYC7BYejr1nENJ44OL2Zte9MTUPzy33evVprceSVZwUlJYd51bDqQGn9PnD9OsD+UsMH0d3OSf5qMZnM4ODg6Ojo4uJiEolkYWHh7u6+YMECPB4fFBQUEBAAALCwsIBloBMSEuBcDgUFhWquW4iNjIyqq6sTExM3b96cmpra1tZmZmYWFBRkYWHRYRk4EBETE4OlKGhubiaRSNwtnz592rp167179wgEwvz58w8fPkyn0729vZOTk6WkpOzs7MLDw7GbK1gs1q1bt86cOfPmzRs6nT5u3Li1a9d6e3vDAQ0sMxAGj8djF56qqqrAwMDY2FgajUalUq2srHbt2mVkZNTduYLJmY4fP75u3boOLykoKLi5uUVERMCnnQ+Q96nm/R5xb+3jx4/+/v5//PEHHo83NzePjIzU0tLClvzy5UtwcPCdO3dKSkooFMrUqVO3bt0K72vifSq6VFdXx13/IzAwcOfOnSwWS0JCArZ89913N2/e5P0WQLzfffg4Nzd327ZtSUlJLBZr8uTJISEhe/bsSU1N7VwLXlxc3MTEBA31ICIrICAgODhYTEyMzWaTyWRTU1Nra+tp06ZNnTq1Q3EIGE5Eo2uTMOBwuOvXr/cqohuWeFzaEEQ08fM1oLa2Vl5eHo/H29raurq6Ojg4dDd+O6B/h6dOnaqoqBgXFyfAbXJ/p+o/KSkpIyMj+D1/8HX+OyzIEddWFjss7onFLyfH+v6qsyXc9Xj0H68/sNv/DYNrG5t33Uw03XVslHeo9ubwZUevpeUVdbe1+6/yYOKlkev3Mdv+/QL9oeLL9ydujvM7qL5x/8KDF58VlAjwEJAOeBSt3rlzJ6w+jy08d+5cDodjbGzceTsNDQ3r16/fvn17WVnZkydPampqZs2a9fjx4y532rn2NHeLn5/f1q1bKyoqIiIiLl26tGLFio0bNwYGBpaXl+/Zs+fMmTO7d+/GVuRd9hreDEChUCwsLODgABaqCaRKO2bEiBHcI66CLUfOT5160FOFcR6nojuo8jiC9A2Hw3FxcYmIiPj7778ZDEZycvKePXu+/fZb/ksaIgiCIP3HZrMfPHjg5uamqKi4dOnS2NhYQaXEGyAsFuv69eu2trbKyspkMtnAwCAyMrLHnCBVVVU+Pj7q6uoEAmHEiBFOTk4vX76EL8Hxbej9+/dLlixRUFCAT7dt24bD4RobG9PS0mCLKNxHKcjAddv1P84kvdi35Nv3B/xSd3mOH6mw8sSNZ/nF8NXK+sZvQ8/9npkT7Pztu/2b7vuvIhMkvou8fDntZZdbm2eo/fnY9rnfaHM3fqyqXbD//Kvi8v9zd8oJ8w1bNif8Xuqn6tout4D0H1a0mkwmjxw5cv/+/Viyh16h0+n79u2zsLCQkpIyMTG5dOlSa2urr69vHza1Zs0aY2NjCoXi5uamp6d3//59Pz8/IyMjKSkp0T7GogAAIABJREFUT09PDQ2NDvdGwrLXcnJyioqK3t7ey5cvj4yMrK+v570XWKU9PDx8/vz5UlJSsEo7h8Px9u7ddABIUVERZibkQSCnGtapp1AosE79ixcvsKFvWGE8IiLCzs5ORkZGW1v7ypUrKioqPj4+/bmDbsuWLe3t7dy5ELurPN7bt4AbrDweGRlpa2srJSUFK4+Xl5f3udsIIkRBQUFXrlzx8vIyMjJCSbCRIeHHH3/E4XDolkJElMFAC4fDsdls/teCiY6ZTObt27cdHR3l5eXd3Nzu3r3bz3RlA6S3gwGgp5EY7tECT0/P9evXl5SUZGRk4PH4PgxpDAJBBq4puZ90VEbMmKhBkhAfIUPZ7TRbS+nfPOzBMUnFX+qCFtvaGoyTJhG1lORPrHYcKSO1PfpBVX0jn7vYdyeZ3twS5Gw7Y6IGhUiYqKoUudL+M72h5zWRPpk7d+7Tp089PDwyMjLgH4L37993mfKBNxKJZGZmhj01MDBQVVV99epVH2IPExMT7LGqqmqHFjU1Ne4CiXZ2dklJSdyrGxoatrW15eTk8N4L7yrtve2zuLh4jz9TCeRUd1mnHj7trsJ4c3PzH3/80au9cMMqj2M3inSuPN63t4Bbd5XH+9xtBBGi1NTUQ4cO5efnC7sjCNIzV1dXrGROh2IkfMJ1b8+ePYLu75AnaqdL1PrDA1YVj8Ph9OF2IVgmqrGxMTo6euHChSoqKr6+vgKfIisuLs59Dp89exYfH8/d0mMJot4OBvA/EuPv729tbS0pKWlmZsZisRQVFQVwwIImyDHfWXqavz35a/Ple8unGRqNVcWL4Z7u+feOiHuv3gMAbPTHYS0EcbzVBPUbz7KT3hUuMTPgZxeP3hYAAGbq/lsFXpkqpaWkUFCJ7q4eEP0sKY6BEw+4W5SUlGg0WmVlpYqKSq82xT2bTkxMDI/HS0pKYi14PJ57ykTfyl4PaJX27gjkVHdXp14gFca7gyqPI0ivfP782c/Pz8/PT1NT08nJyc7OztLSEg29iqBDhw7BWx6Q/uBR5vTt27foLuIORO10iVp/BIXHlGD4UnV19fHjxw8fPiwpKamurp6bmzthwoT+77fDoGVv73G1s7PrUD7H0NDw0qVLOTk55ubmXa7CeySG+wutqakpv4chPIIccQ1dOvfo9wuLquu+i7yi5XfA5ei1ey//V2GplcWub2YSJcSlSATuVUZIUwAAlfyNuLay2A0trUQJcQrxPxtRlJbsbhWkn3A91cgWExPr8J+fOzjBwDiQW2VlJQBASUmp88ICxE/Za1ynCmwCr9KenJzcY8q7Hk91f/BZYbzzqeAHqjyOIL2C/QRTWFgYGRlpbW0tJye3bNmya9eudfn3E0EQBEEAAHQ6fdeuXQYGBnJycnCEFmbW7G4wAI5btLe3U6lU7nHdv/76CwDw4cMH7oW509aILEGOuOJwwNlM39lMv43d/jSv6Fhixg+nbv3y3ex1s80I4ngZMrG+mdnQ0sodu1YxGgEASjJ8nSmCOF6KRGhoaW1ktnLHrnVNvS5kjPBJVlY2IyNjwoQJsGi1paUlhUKJj4/38/ODC6ioqJSVlWHLV1RUFBcXd04x0tDQ8OrVK6wm8ps3b2g0mqGhYW+HW3uFu+w11ti57LWkpCQWe+vo6GzevNnDw8PJyens2bNpaWkzZszAlgwLC4uKiiosLByI29N7PNX9tGjRot9++y0+Pt7FxQW2dK4w3uWp6HHLsPL4li1bYOXxt2/fYi/x+Rb0aN68edHR0QkJCYsXL4Ytw6PyOPJ14v5yAKukMhiMGzduwKyVJiYmTk5O9vb2urq6QusiAgAAYNOmTUN3QAlBEB5gVuEuXyIQCK2trYqKisuXL3d2dj58+DAAQCDDrf1nb2+fkpISGRm5bNkyWG0xIiJi06ZN3Q0GwJGYhoaG5ubmvn137duQxsAR5Ijr+M0HP1R8AQBI4MVmTNQ4v84ZhwN/Zv8v8+d8Qx0AQGL2v3f1tLLYKbmfSBLiMydqdrnBzmbraQEAHr0txFpqGpryP6OBlwHEu0b2t99+S6PRjh492tDQUFBQ4Ovr2+UgKoVC8fLyevbsWWNjY2ZmpqurK4FAiIyMHNCe81n2evLkyXl5eSUlJenp6YWFhVZWVkCgVdqzsrIUFRUtLS17TPvWz+rtvPFTYbzLU8EPVHkcQfjX5UeXzWa3t7e3t7e/ePFi586denp66urqr1+/rqqqGqB8GFOnTu0w5QxBEOSrJSEhgcPhKBTKkiVLYmNj4RckS0tLYffrX9yDASNGjIAhZY+DAU5OTiwWKy0tjbsxLCxszJgx/FxcOgxpnDp1qq/dFwwBDxxtvXo/eMm340Yq1De3/PbkLw4HWOmMhS/tcJz59EPxzpt/UogE8/FjPtc3BMckfa5vOLB8/gj+RlwBANsXWj/O/RRw408ZEtFEU62spn7XrUQKkVDf3LGWY2+p3r3brqwMs78qKCiMGDFCUVERe6qgoKCoqDhixIgub3ocxh4/fnz8+HEXF5eioiISiaStrX369Ok1a9ZgCwQFBbW0tOzbt2/r1q3GxsaHDh0qKCjIysrC4XD+/v6KiopwDoOamlp4eLi/v/+LFy/YbLapqemjR49gHVfuCqI4HG7Hjh0mJibYvZ1kMnnFihVeXl7Y3H0ymbxjxw5HR0csEREOhwsJCbG0tMQCLRwOt3v37j179ly/fn3nzp1HjhzZsWOHvLz8vHnzli9fHhoaamtra2xsnJmZCQCIiIhwd3efOHGivLx8ZGTkxIkTwT9V2oODg728vEpKSmRlZSdNmnTnzh0bG5venkM4wZg7xx13qVJ4gJcuXerxVHcnIyOjw8kJCgrCfiGbNGnSggUL4uLiYIXxoKAgHx+f0tJSSUnJqVOnJiYmcsfGXZ4KfsDK4/v37++y8jiPt8DFxaXHd//SpUuw8ri/v//ixYvb2tr09fV379596NChhw8f4nC4NWvWwKI+CDL46uvr4W3YTU1NTCaztraWyWQ2NTVh7Y2NjUwms66urqWlpbm5mU6n854PjGVuLCoqAgDQ6fTU1NQ+pMRDEARBeiQmJsbhcAgEgoODw4oVK+bOnQtThIggOBjw6NGj/fv3//DDDxQKJSMjo8fBgJCQkMePH69evfro0aPTpk1js9k3btzYu3fvuXPn+BmJmTx5cnp6eklJSWlpaa+GNAYI7j+Dy9HRYOlSwN2Cw9HXLGIa8/X9Nae08reUrPQPJaU1dKKEuJaS/IpphsunGWGDzLWNzeH30xJe5ZXX1ZMJEsYaal62Uy111AEAxxKf/fL7Q2xTG+daGI1VWXXy36QI35nqH1u1EABQUFkTePtR6vuiNjZ7guqILQusTj58nvL+EwBg+TTDQ67/Jk3lQWn9PnD9OsCmAC1Zcr2kpHL58i9fvlRXV3/58qWqqgo+qK6ubmn5NyqWkJDA4lgsvoUt8vLycnJy8vLy8IHIfu6RAYKqtIsIfiqPI0hDQwO8+ae5ubmlpaWuro7JZDY2NjIYDCaTWV9f3117hwC1u+3LyMjAjGJSUlLwJnMymUwikWRlZVks1rlz57pbEWaYk5OTc3d3f/PmDYVCGUKF74cTXKfC9wiCDBtwqjAej7e1tXV1dXVwcOhuGhf8IyAif4erq6t37tx57969iooKOBigrKwcGhoKAOgwGAAAgCMZAICamprg4OCYmBhsJOann36CIzHcgx9Qh1nH79+/d3d3/+uvv+Tl5bdt27Z+/fp+HnKvdP47LMjAdQjpHLgCAEA3H8rGxkYYwVZVVWGRLdaCPeWObwEAUlJSHUJZeS7c7R0SvSJDFApcRQQKXIeluro6NptNp9Pb2toaGhrg6GVjY2Nra2t9fT2bza6trWWz2fX19a2trY2NjTDsbGhoaGtro9PpbDa7rq6OxWLB+JNHwEmhUOBNQSQSiUwmU6lUIpHYZfxJJBIpFIq0tDSRSJSRkZGUlCQSiXJycnBFHsfCYDA6JwIAAEhISLBYrOnTp2/YsMHR0VFCQkKkvjB9bVDgiiDDWFNT04ULF5ydnRUUFHgvOaB/hxHeOv8dFnyOmeGHQqFQKJQxY8bwXqy5ubmmpqa2trampqbzg6KiopcvX3758qW2trbDPDEJCQkYwcrJyVH/ISsrCx/IyMhg/1KpVDk5ORkZGVQ4QWT9+OOPP/74I4VC6Vu9O6TPtm3bFhYWJuxeIABGjwCA2tpaAACDwWCxWH2LLeHYJtwCjz1KSUlJSEhQqVQ8Hg/zgcNgUlJSUklJCWalFhcXl5WVxePxVCpVQkJCSkoKizPhkjIyMnDJQThFFAoFh/v3V2M4xCorK+vh4eHu7q6lpTUIfegt7hsccnNzAwICHj58CDN7V1VVKSoqVlVVBQYGxsbG0mg0KpVqZWW1a9cuIyMjuAqTyQwODo6Oji4uLiaRSBYWFu7u7gsWLMDj8UFBQQEBAQAACwsLWDIxISFh3rx5AAAFBYXq6uoOe//06dPWrVvv3btHIBDmz59/+PBhOp3u7e2dnJwsJSVlZ2cXHh7O/T7y7hiCIF8nSUlJNMwwFKHAVWDIZLKamhp3ZprutLe3dxni1tXV0el0Op1eWFgIH9fX19Pp9A5juQAAKSkpLJSFD2DQCx9LS0tTKBQqlUoikSgUCjZjDUW8A8rV1dXV1XUgtswjpRu8lXcgdir0XfdWaGgonC2D8ABjRThoyeFw4I9oMKqEo5cwYsSCz7q6Og6HA0PHLteFefa51+XdARwO1yG2hAEkjC01NDS4Y0s4dEmhUAgEAvzzJScnh8fjZWRkCAQChUKBg5+DcN4ES0xMjEgktrS0wCFWCwsLLy8vBwcHUb7BxNHR8f/bu9OoKK6tb+C7uhFoGqSZBOcxgpeoUUBA4YoMShQehidqjOIAKCxHJLqciEmQqETUYMAxb4i5IUZRQRQxiQHxhiEgEY24VNSIIhJxYB6kod4PldTTNqNM3ej/9yGr+tSpU7s6bVO7z6lzWJZ1d3c/deqUn5/fJ5988s033/zxxx/cVAWPHj2ytrauqan5+uuv//3vf+fn5y9btsza2jopKYkbhLZ8+fKYmJiYmBgbG5uysrKwsDA3N7fk5GQ7O7ugoKCgoCDZQXrOzs4sy5qbm9+7d6/x2QMDAzdu3Pj111+fPHly/vz5T58+VVVV3bJly4gRI6Kjo/39/bW0tPiFxFoNDAAAepDWElc1NUZa30qdnoapkxIRtTiUq0sJBAJu5qc21ucerOJyWj655Uu4jbt37/Il3HQgTTbF3Q5qaWmJRCJuQ11dXUtLS1NTUyQScRvq6uq9e/fmbha5u0nu7pA7lrvvJCKkwd2m7Uuevk6nfu1xXYtExKWCshtchyQR8akgNzKW/sk8iYjrjZRLPrnCJpNPrmOz1aia/GfO5ZZcnqmurs7NHC6RSBiG4Xo7W/iK4L5J+E5RgaAzp7LvucRisbq6+uLFi5csWTJixIjuOamKiorsLHEc2R+nDA0Ni4qKWm1n3bp13GRRlpaWXGf4woUL8/Pzo6Ojp0+fTkSmpqY//PDDkCFDVqxYwc2B98svv5iamjo5ORGRSCTasWNHfHx8+67Cx8fHzMyMiLy8vEJDQxMTE1NSUrgeVD8/v9DQ0LNnz/KJ64YNG1oODAAAepBWEldWRyKobOUX9B6HqawmImptULvyUFNTMzAwMDAweKWjysrKuGF4bdl49OhRdXV1RUVFeXk5v9HGabLV1NS43g+BQMDNuszdnnI3rFyfCdfBQkQ6OjpExOXDfE3ZEq5BIuKfE+MaJyK+EYD24TNDImpoaCgtLeV3cdkd/ZMQEhHXi0hEfMrH/6PgskT6p79R9nB+gxsoyyeW/On4fPKVcDkhyfxz4NJIejmB1NXVFYlErSafXKel3LGtPpkJnSg6OtrOzo77rus2cl/p7X7GdcKECXIlcXFxAoFAdnEdIyMjU1PT7OzsgoKCAQMGODs779u3b8mSJd7e3hYWFkKhsN3rMJubm/Pb/fr1y83NlS3p37//lStX2h5Y+2IAAACFaCVxZUb9S6WwuHtC6TZ/X5FyLCXcdXr37t27d+8mV1Vtu8bjAJvsxmlh/OGzZ89qa2u5HiT+3p2/3edu7l8Vf0dO/9x5k0wPMHcXzu2Vy3X5+3UOn2k3bpbDpdk8/lyyWr3d51Px5sgG3M1a7YXjk7dXrcB/DHh8ByOv8chSPmnk8Skip7lsk2SySrl2+L7KduP/D3K/xchu8P/v+F9eBg0axH0O+R9l+I8N/3HiNvjPG/855D+f/OeWz1fhNTNt2jRFh9B+3E8nPG5yZiJqcrm4vLy8AQMGREZGWltbHz582MHBgYhsbW39/Pz4x1Zfidx3OPejDF/CPTDc9sDaEQAAAChKa0OFJ01SPbC3WyLpPqo379GI4aSrq+hAegDu771c/tYV+FSWTz/4jIhPPPjxk3wKJJvG8DmMbKojl7RUVVVxU31w+AY5st1x1CjRal9H2ZuMz+V4ch8kud8RSKY7kSeX9gsEgqFDh/I/H8ieQrYm3xtJL+d+cj9VyP4SwTfF/xLRQ5+fBOhm3CTMFRUV1dXVza0KyDCMl5eXl5dXXV3dhQsXwsLCPD09d+7cGRgYyFUQCARyP4G1vNptZwUGAAA9SGtf5S4ugpAQlfxH0sF9uyWerseyaldv07wFio4DXsKnE92QJHcuPuVuTsu9ynJdiN2s1dHXrVZonHwCwJvG09Pz66+/Tk1NnTx5Ml8YGhoaGRl59+5dbkrnjIwMExOTXr16OTk52djYiMXihIQEPnHt27fvw4cP+WOLioru37/f8e+WVgPrYPsAAN2poqJi3LhxxsbGb+xKZi9/a3Nf4vX1xE+6Y2nJjjLRuPh7mdeM7g6ta6jm3hX+9YQWLXqpVCql7n3WCF4bTQ5Ck9XjUnEAgFeybdu2lJQUb2/viIiIiRMn1tfXx8TEBAcHR0VF8cmhv7//nj17jI2NS0tL9+3bx7Ksvb0938LUqVMjIiIiIiIWLlz4119/bdy4sU+fPo1n1O+KwAAAegqWZRsaGuT6SzQ1Nd955x1uObHX3ssTPHK34C/3/zAbN6n/9odKwV/dGFWXaWjQik+hGTPI1PSl8tJSevnhRgAAAOBkZGQwDHPq1CkiEolEck/79+nTJzMz093dffny5QYGBiYmJidPnjx16hS/anxKSoqJicn777+vq6s7atSoc+fOHTp0aOPGjXwLISEhvr6+W7du7dOnz8KFC9euXWtkZPT06VOGYdavXy939qCgoEuXLjEM8+OPP9bX1zMMs3379l9//ZVhmJSUlMrKSoZhuMW6Wg0MAKAH0dLSunPnztmzZxUdiMIwLy13cfcuDR9O6elkZfV/hSxLtrZ1jwueB8ylZtd07BlEFy5pxSbTtWs0cuRLOwYMoFWraO1aBcUFAAAgj8uvjh07puhA3kQMwxw9ehQpLsAbTvm/h1/jHtfG38Mv97gOHUo6OpSeLncQhYf3uvNAdCGrW4LsKsKip5oJv9KHH8pnrQUF9PAhjRunoLgAAAAAAOA1V1xcvHLlyiFDhqiqqhoYGHh6eubk5HC7bGxsmH/MmzePiBwdHfmSkpKSuLg4/iX3JEVYWBjDMJWVlampqVz5a/8QxMuJK8PQtGl0+rR8LTMzCgnROvGL2h+3uy2yziWorJYcPMEYm9BHH8nvi48nsZhsbRURFwAAAAAAvOYePXpkYWFx7NixvXv3Pnv27MKFC8+ePbO2tk5PTyeiX3/9NScnRywWjx079sCBA0SUkJBgaWl55MgRlmUlEom7uzvLsm5ubnyDa9asYVlWLBZPmjSJZVmWZWXX67a3t9fT08vIyOj+K+06AvmCOXPowgW63ShB3bCBvLx6Hz7d615h90TWiZiaWu2DJwSqIkpMJJkF3/721Vf0v/+LyZkAAAAAAKArbNiwIT8/f9euXdOnT9fU1DQ1Nf3hhx9Yll2xYgVXYezYsVFRUVeuXJk/fz7Lsn5+fg4ODu+//377TtfQ0MBls513BYrXKHGdMYOGD6ePP26i7sGDzOTJkvDv1S7f6IbIOovwaanuru96ldUwZxOpTx/53bGxlJNDy5crIjQAAAAAAOjBrl27xshY3kxaERcXJxAIXFxc+BIjIyNTU9Ps7OyCggKuZObMmZs2bTp58qSNjc3Tp0+3bNnS7qj4Ht12t6CEGiWuQiHt3ElHjtDFi/K7VFXp9BlmiZ/2V7HiMxeZOql8BeWjeu2OTti3At0+lHVJfiZhIqqtpXXraN48srBQRHQAAAAAANCDvf3226yMiIiIxnVqa2tLS0sbGhq0tbVls9zff/+diPLy8viaW7ZssbS0TEtLmzlzpkDQKFN7szX1dvzP/9DUqbRqFTVeQk0opD17aO9eccrvup/9P7Wcm90QYvsIHz+T7D8u2XtU8O4MJjWNBg5solJICD16RNu3d3t0AAAA0E5Hjx595513uIV5GIa5du2aoiMCAGiJmpqaRCJRUVGpq6tjG5kyZQpf88KFC6WlpaNHj166dOmVK1dabVlufbLXWzN5fEQE5eeTtzc1OTDa359u5QmdnLUPndQN/UZ0MVtQUt6lUbYd86JO7Wqe9ldxeiGHVOtVKDmZjhwhTc0mqh4/Tlu30o4d1K9ft4cJAACgjKysrGRHsilWRUXFW2+9JRdPamrqnDlzpk6dWlxcfPv27QEDBigqPACAtvP09JRKpampqbKFoaGhgwYN4idV+vPPP318fE6cOBEfHy8Sidzc3IqLi1tuVkND48WLF9y2sbHxwYMHuyJ4JdHMpMkjRlBMDL37Lo0cSZ980kSFfv3ou+8oIEAlPFzr5AmtH35s0Nep19dpEKmSgvJ+prZOWFohLCqmBpasrOibwzR7NjU3K3RWFi1YQMuWkb9/94YJAAAA8ppcipBl2YaGhoaGBtnCmJgYlmVXrVqlqampqan54MGD7o0UAKA9tm3blpKS4u3tHRERMXHixPr6+piYmODg4KioKG4Zm4qKCnd39y+++OJf//oXER0/ftzJyem99947f/58r169mmt2/Pjx6enpDx48KCgouHv3ru0/66TY29tfuXIlISHBysqqey6wGzS/2o+DA0VGkp8flZfT55+TUNhEHXNz+s9/6NAh+vVXwe+/C/78k54/p5f/wHQfLS0yNKSxY8nOjgwNW6qZmEjvv092drR7d3cFBwAAAK9GS0vrzp07coVcpqqnp6eIiAAA2qlPnz6ZmZmfffbZ8uXLHzx4IJFIxo0bd+rUKUdHRyJavnx5ZGQkEbm5uf3xxx9GRkZ2dnZEdPHiRVVV1S1btrz99tseHh5cUyKRaO7cud999x0RffHFF4sXLx41apSurm54ePioUaO4OlKp9PWbVbjFZWoXLyZNTfL2prw8+u476t276Wrq6uToSI6OXRFfJ2NZ+vJLCgwkLy86cKDpbBwAAACUVX19vaJDAABoD11d3Z07d+7cubPxroiICLlZnRrnnE1mocbGxhcbT6lL1GRhT9faXFVz5lBSEmVmkokJHT7c9COvPUVODtnZ0erVFBJCUVGkqqrogAAAAHqwuLg4fm7Me/fuzZ49WyKR6Onpubi4yPWUPn36NDAwcPjw4aqqqjo6Ou+++25ycjK3KywsjGGYysrK1NRUrilu1Jxs4zU1NXzJqVOniIibmcnExER2fs6QkBAikkqlfMl7773X3W8KAAB0jTZMsmxtTdevk4cH+fiQlRUdO0b/PAHcY1y6RIsWkbk5SaWUmUnr1ys6IAAAgB7P3d2dZVk3NzciCggICAgIePjw4dGjR5OSkubMmcNXKyoqsrCw+P7778PDw588efLbb79paGg4ODh89dVXRLRmzRqWZcVi8aRJk7iBbdw8JbKNNz5ddXU1y7I3btxgWXbatGkCgeD27dtBQUFEpKKiwrKstbV1dHT08ePHu/k9AQCALtLiUGGeru7fz7tu3kwffEAaGmRvT+PG0YABzY4fVrjqanryhK5do+RkuneP3n6bvvmG5s5V1NxRAAAASkhFRaXx4FvZ9RUMDQ2LiopabcfX15db6d7R0XHGjBnHjx9/8uSJvr4+EW3YsOHPP/88cuQINz9w7969v//++2HDhq1cudLV1dWw5Wkp2iAwMPDHH3/ctWsX94QYEaWmpt6/f3/mzJkdbBkAAJRH2xJXzpgxFBdHBQUUH09JSRQdTX/9RWVlXRZbx6irk44OmZrSvHnk6koTJig6IAAAgFcgFApfdP0QJ34ZBo6VlZW+vv6ZM2detR0LCwt+e+DAgURUWFjIJa6xsbFENGPGDL6Cmpqag4PDf/7znx9//HH+/PntDp4zderU0aNHf/PNN8HBwdykTTt27FixYkUL83C2jHtPVJpbmAAAABTh1b+UBwygpUtp6dIuCAYAAAD+pq2tffv2bUVH0Vba2tr8tqqqKhFxy9jU1taWlpaqq6traWnJ1uc6WtvSl9sWAQEBPj4+e/fu/eijj27dupWUlBQVFdXu1kpLS4lIIpF0SmwAANAp2vCMKwAAAHS7oUOH3rx5U9FRdJSampq2tnZNTU15ebls+V9//UVERkZG3EumYw/yzJ0719DQMCIiora2dufOnQsWLNDR0Wl3a9zbPmzYsI6EBAAAnQuJKwAAgDIyMzMrKCgoKChQdCAdxa09mJCQwJfU1tb+8ssvIpFo2rRpXImGhgY/LtrY2PjgwYOvdAo1NbWlS5c+fvx4586d0dHRq1at6kjAv/32m46OzuDBgzvSCABAy6ysrLgn/6GNkLgCAAAoIxsbG7FYfPr0aUUH0lHbtm0bOnRoQEDAmTNnysvLb9269cEHHzx69Cg8PJyfmWn8+PG3bt168OBBenr63bt3bW1tX/UsS5cuFYlEQUFBjo6OI0aM6EjA8fHxzs7OHewEBgCAzoXEFQAAQBmxFpYzAAAQyElEQVSpq6t7enpya8Yop4yMDNmFVbnVaBiGCQ0NJaJx48ZxnQlGRkZZWVlz5sxZuXKlnp7ehAkTKisrz58/v3jxYr6pL774YsyYMaNGjZo9e3Z4ePioUaPkVm2dN29e43VcMzIy+Bb09fXnzZvHsmxgYGBHLiovLy8lJUV2OR8AAFAGDMuyio4BAAAAmpCVlWVpaXnixAlutC20LCoqKjIy8tKlSx1pZO7cuZmZmTdu3BAKhZ0VGAD0ULNmzSKiY8eOdUXj7Z7F/Q3BMMzRo0e5/wUc9LgCAAAoKQsLi7lz565Zs6ampkbRsfQA+/fv72B3a1pa2pEjR3bt2oWsFQCUCjfkhHPz5s1Zs2bp6elxL588eUJExcXFK1euHDJkiKqqqoGBgaenZ05ODn94bW3t5s2bTUxMNDQ0dHV1XV1d4+PjuUW8Q0JCuHZsbGy4yufOneNKuCXN5M6en58/e/ZsLS0tPT09Ly+v58+f37t3z9XVVUtLq2/fvosXL5abiq/lwF4NCwAAAMrq4cOHmpqaQUFBig5ESR06dMjd3b28vHzfvn1vvfVWXV1du5uqrq5+5513pk2b1onhAUCPNnPmzJkzZ3ZR45aWljNmzHilQ9zc3Iho8uTJycnJlZWVGRkZQqGwuLi4sLBw8ODBhoaGCQkJ5eXl165dmzx5srq6elpaGnegr6+vtrb2Tz/9VFVVVVRUtGbNGiJKTk7mWxaLxZMmTZI9l5mZmZ6eXuOze3p6Xrp0qaKi4ttvvyWid999183N7fLly+Xl5fv37yei1atX84e0GlgLiOjo0aMvlbzSmwUAAADdbN++fQKBICYmRtGBKKNDhw4RkYqKypgxY7Kzs9vdTkNDw5w5c3R0dPLy8joxPADo0To3cW11KIehoWHLLXCp49mzZ+XKFyxYQETR0dF8yaNHj9TU1MzMzLiXQ4cOnThxouwhI0eObF/impCQwJeYmpoSUUpKCl8ydOhQY2PjtgfWgsaJK4YKAwAAKDV/f/9ly5YtWLAgKytL0bEoHV9fX5Zl6+rqrly5Mn78+Ha38+mnnx4/fjwmJqaDMxIDwOtEKBRy42k7hVQqlU3DGve4FhUVtaWdCRMmyJXExcUJBALZxXWMjIxMTU2zs7O5NdWcnZ3T0tKWLFmSkZHBXdHNmzft7OzacRXm5ub8dr9+/eRK+vfvX1hY2PbAmiOVSolIRUVFthCJKwAAgLLbvXu3nZ2do6NjYmKiomN53dTX13/44YfBwcGRkZEODg6KDgcAlIi2tnZpaamio5AnFotlX9bW1paWljY0NGhrazMyfv/9dyLKy8sjosjIyG+//fbu3bsODg69e/d2dnaOjY1t39l79+7NbwsEAqFQqKGhwZcIhcKGhoa2B9Yc7m2XSCSyhUhcAQAAlJ1QKIyNjfX09HR1dd2zZw+LFQE6SVlZmYeHx969e6Ojo2WX5wEAIKKhQ4fevHlT0VG0Qk1NTSKRqKioNPmQ/5QpU4iIYRgvL6/z58+XlJTExcWxLOvp6blr1y6+EYFA8OLFC9lmS0pKuiGw5nBv+7Bhw2QLkbgCAAD0AKqqqlFRUSEhIatXr7azs2v/rIxAREQsyx4+fNjExCQzMzMpKQkLtwJAY2ZmZgUFBS0PalUGnp6eUqk0NTVVtjA0NHTQoEHcmFuJRHLjxg0i6tWrl5OTEzdLcEJCAl+5b9++Dx8+5F8WFRXdv3+/GwJrzm+//aajozN48GDZQiSuAAAAPcb69eszMzOlUqm5ufmiRYs6uGbpm+nFixfHjh2zsrLy8fHx8PC4fv26tbW1ooMCAGVkY2MjFotPnz6t6EBasW3btuHDh3t7eycmJpaWlj579uzAgQPBwcFhYWH8Y6L+/v5Xr16tra19/Pjx559/zrKsvb0938LUqVMLCwsjIiIqKiru3LmzatWqPn36dE9gTYqPj3d2dmYYRraQwXAjAACAnoVl2ejo6O3bt+fm5g4ZMmTKlCmjR4/W19dXV1dXdGjKq6ysrKCg4PLly0lJSVVVVS4uLsHBwWPGjFF0XACg1ObPn5+bm5udnd3pLVtZWenr6585c6YtlTMyMuR+YpNL4p49e/bZZ5/FxcU9ePBAIpGMGzdu7dq1jo6O3N4rV67s27fv4sWL+fn56urqI0eO9PHx8fHx4TPD0tLSNWvWJCQklJSUmJmZ7d6929/fn7vqdevWubu7y55906ZN7u7uFhYWfMm2bdtsbGxsbW35ko8//viTTz5pNbAm5eXlGRsbnzp1ytXVVbYciSsAAEBPlZmZefr06YyMjNzc3OfPn9fU1Cg6IuWlpaVlaGg4duxYe3t7Nze3/v37KzoiAOgBsrKyLC0tT5w44eHhoehY3hRz587NzMy8ceOG3AJCSFwBAAAAAACa5uXllZaWlpubi1Et3SAtLc3GxqZxdyshcQUAAAAAAGhOYWGhsbFxQEDAli1bFB3La66mpsba2trQ0PDcuXON92JyJgAAAAAAgKb169dvx44dW7duPX78uKJjeZ2xLOvt7Z2fnx8REdFkhZZmcwIAAAAAAHjD+fv7X79+fcGCBYMHD5adlAg60aeffnr8+PHExMQRI0Y0WQE9rgAAAAAAAC3ZvXu3nZ2do6NjYmKiomN53dTX13/44YfBwcGRkZEODg7NVUPiCgAAAAAA0BKhUBgbG+vp6enq6rpnzx7ME9RZysrKPDw89u7dGx0dvXjx4hZqInEFAAAAAABohaqqalRUVEhIyOrVq+3s7HJychQdUc/Gsuzhw4dNTEwyMzOTkpLmzJnTcn0krgAAAAAAAG2yfv36zMxMqVRqbm6+aNGiS5cuKTqinufFixfHjh2zsrLy8fHx8PC4fv26tbV1q0dhORwAAAAAAIBXwLJsdHT09u3bc3NzhwwZMmXKlNGjR+vr62Ot1xaUlZUVFBRcvnw5KSmpqqrKxcUlODh4zJgxbTwciSsAAAAAAEB7ZGZmnj59OiMjIzc39/nz5zU1NYqOSHlpaWkZGhqOHTvW3t7ezc2tf//+r3Q4ElcAAAAAAABQanjGFQAAAAAAAJQaElcAAAAAAABQakhcAQAAAAAAQKkhcQUAAAAAAAClhsQVAAAAAAAAlBoSVwAAULCKigpGRnp6enM1165dy1cLCQnpziAVRVNTk2nRV1991blnPHbsGMMwampqndssAABARyBxBQAABdPU1GRZ9vLly9zLLVu2NFnt6dOn+/fvJ6K5c+eyLBsUFNR9IbZXRUXFW2+95eLi0pEWuHfGzc2NbWTy5MmdF+zfDAwM+P8CAAAoCSSuAACgLEQi0eDBgxMTEy9dutR47+7duwcOHNiOZjU1NW1sbNpe3olYlm1oaGhoaOjSs3QuJK4AAKCEkLgCAICyEAgE69evJ6LGw4BLSkr27du3bt06RcTVflpaWnfu3Dl79mwXtX/hwgVfX9/ObROJKwAAKCEkrgAAoEQWLVrUv3//+Pj4q1evypbv2bNn+vTpw4cPV1Rgymb58uUBAQFd0bK+vj7DMEhcAQBAqSBxBQAAJaKmprZ27VqWZT/77DO+sKKi4ssvv9y4cWPj+lKp9OjRo05OTkZGRiKRaPTo0eHh4fzQ3LCwMIZhKisrU1NTuamMVFRUWijnFBcXr1y5csiQIaqqqgYGBp6enjk5OdyuuLg4flakmzdvzpo1S09Pj3v55MkTudhkK9fU1HCFtbW1mzdvNjEx0dDQ0NXVdXV1jY+Pr6+v78ibFhISwp2FH/l87tw5rkRfX79xMPfu3Zs9e7ZEItHT03Nxcblz545sa0KhUEdHB4krAAAol8YzPQAAAHS/y5cvi8VilmWrqqoMDQ0FAsH169e5Xdu3b581axbLsv/973/pn8mZOKdPnyairVu3Pnv2rLi4eM+ePQKBYM2aNbIti8XiSZMmNT5jk+WFhYWDBw82NDRMSEgoLy+/du3a5MmT1dXV09LS+Dpubm5ENHny5OTk5MrKyoyMDKFQWFxc3OR1cZWrq6u5l76+vtra2j/99FNVVVVRUdGaNWuIKDk5ueV3psm/4KtWrWr5cszMzPT09BoH4+bmlpaWVlFR8fPPP4tEIgsLC7kzGhsbh4SEtBASAABAN0OPKwAAKBeRSBQYGNjQ0LB161Yiqqqq2r1796ZNm5qrb2dnt2HDBh0dHX19/RUrVnzwwQfh4eFlZWXtO/uGDRvy8/N37do1ffp0TU1NU1PTH374gWXZFStWyNVct26dnZ2dhoaGpaWlVCrl+zZb9ssvv5iamjo5OYlEIkNDwx07dowcObItB8rNKrxs2bJXvrZ/+Pr6Wltbi8ViR0fHGTNmZGVlyXUX6+vr6+nptbt9AACATofEFQAAlM7SpUv19PSOHDly+/btAwcOWFlZjRkzpsmaLi4uycnJsiVjx46tq6vLzc1t36nj4uIEAoHsAjZGRkampqbZ2dkFBQWyNSdMmNCO9p2dndPS0pYsWZKRkcGNEL5586adnV37om0fCwsLfpubqLmwsFC2goqKiuzYaQAAAIXDnyUAAFA6mpqaAQEBH3300ccff3zhwoVTp041V7O0tHTnzp2xsbEFBQUlJSV8eVVVVTvOW1tbW1paSkTa2tqN9+bl5Q0YMIB/KRaL23GKyMhIa2vrw4cPOzg4EJGtra2fn5+Hh8erthMREdGOs3Nkr05VVZWIetaCPQAA8AZCjysAACijFStWaGtrf//992PHjjU3N2+umqur65YtWxYvXnzr1q2GhgaWZXfv3k1ELMvydRiGafLYxuVqamoSiURFRaWurq7x0zVTpkzp+HUxDOPl5XX+/PmSkpK4uDiWZT09PXft2tXxlgUCwYsXL2RLZDP5V9IVq+wAAAB0BBJXAABQRtra2oGBgdra2kFBQc3Vqa+vT01NNTIyWrlypYGBAZeIVldXy1XT0NDgMzpjY+ODBw+2UO7p6SmVSlNTU2VbCA0NHTRokFQq7fh1SSSSGzduEFGvXr2cnJy4yX4TEhI63nLfvn0fPnzIvywqKrp//37HmwUAAFAGSFwBAEBJbd68uaSkZOLEic1VEAqFdnZ2RUVFO3bsePLkSXV1dXJy8v79++WqjR8//tatWw8ePEhPT797966trW0L5du2bRs+fLi3t3diYmJpaemzZ88OHDgQHBwcFhbWWY99+vv7X716tba29vHjx59//jnLsvb29h1vdurUqYWFhRERERUVFXfu3Fm1alWfPn3a0U52dra+vr6NjQ3GDwMAgBLphpmLAQAAWib7vOi0adOarCP39+vLL79kWba4uNjPz2/gwIG9evUyNDRcuHDh+vXruQpmZmbcgTdu3LC1tRWLxQMHDoyMjOQbbK786dOngYGBw4YN69Wrl4GBwdSpU3/++WduV3p6etv/jMbGxsrW5FbxycnJ8fPzGzVqFLeOq5WV1aFDh7hBzq2+M0RkaGjYXM2SkhJfX9++ffuKRCIbG5usrCwzMzPuqHXr1slFvmnTJrm3dMaMGVw7WVlZXGD19fUtXB0AAEB3YthGtwIAAAAAAAAAygNDhQEAAAAAAECpIXEFAAAAAAAApYbEFQAAAAAAAJQaElcAAAAAAABQakhcAQAAAAAAQKkhcQUAAAAAAAClhsQVAAAAAAAAlBoSVwAAAAAAAFBqSFwBAAAAAABAqSFxBQAAAAAAAKWGxBUAAAAAAACUGhJXAAAAAAAAUGpIXAEAAAAAAECpIXEFAAAAAAAApfb/AfuQOGa6+j4gAAAAAElFTkSuQmCC\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": "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\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": "iVBORw0KGgoAAAANSUhEUgAABOgAAACnCAIAAAAkHPQUAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeTyU+R8A8M8YZtyMK1flyt2h0SGUDbslNtl00rYKbZvoQqKUig7VbKe27VQbtZHUquhkqWhXrZJKznHfxDDM749ne36zjjHOGXzfr33tazzzHN/nGXnm83y/38+HwGKxAEEQBEEQBEEQBEH4lQCvG4AgCIIgCIIgCIIgnKDAFUEQBEEQBEEQBOFrKHBFEARBEARBEARB+JogrxuAIPyFwWBkZGSUlpbW1dXxui0gICAgLS2trq6urq5OIBB43RwEQRAEQRAE4Q0UuCIIAEBVVdXFixejoqKSkpKYTCavm9MehUL55ptvli1bZmNjQyQSed0cBEEQBEEQBBlUaKgwMtJ9/vw5MDBQVVU1ICBgzJgxFy5cePv2bW1tLYsPtLa2lpWVJScnBwQElJSUzJ8/X1dXNyYmhtfXDEEQBEEQBEEGFYGFyuEgI1hUVJSXl1d1dbW/v/+aNWskJCR43SJOPnz4sGPHjt9++83a2vr48eNaWlq8bhGCIAiCIAiCDAbU44qMUCwWy8/P77vvvrO0tMzKytqyZQufR60AoKWldfny5SdPnpSWlk6dOjUhIYHXLUIQBEEQBEGQwYB6XJGRqLGx0dnZ+datW6dPn/7+++953Zwea2pqcnFxuX79+vHjx11dXXndHARBEARBEAQZWCg5EzLitLW1OTs7P3z4MD4+3tzcnNfN6Q1hYeHLly9ra2u7u7uLi4svXbqU1y1CEARBEARBkAGEAldkxPH394+Jibl79+4QjVoxBAIhMDCwrq7OxcVFTU3NxMSE1y1CEARBEARBkIGChgojI8uNGzcWLlx47ty5oThCuKO2tjZ7e/vnz59nZGTIysryujkIgiAIgiAIMiBQ4IqMIJ8/f9bT07O0tDx79iyv29JvamtrdXV1FyxYcPz4cV63BUEQBEEQBEEGBMoqjIwg+/btq6qq2rNnD68b0p8kJSWDg4PDwsLS09N53RYEQRAEQRAEGRCoxxUZKaqqqlRVVQMDA7ds2cLrtvQzFos1ffp0RUXFmzdv8rotCIIgCIIgCNL/UI8rMlJcvHiRSCSuWbOG1w3pfwQCYdOmTbdv3y4oKOB1WxAEQRAEQRCk/6HAFRkpoqKi7O3tJSQkeN2QAWFvby8qKhoTE8PrhiAIgiAIgiBI/0OBKzIiNDU1/fnnn3PmzOF1QwYKiUSaPXv2gwcPeN0QBEEQBEEQBOl/KHBFRoS3b9+2tLQYGRnxuiEDyMjI6PXr17xuBYIgCIIgCIL0PxS4IiNCUVERAIwePZrDOgcPHiQQCAQCQVVVdbDaxcnVq1ex9ggLC3OzvqqqKnaaCIIgCIIgyOB49uxZQECAlZWVsrKyiIgIAemapKTkuHHjFi5ceOLEiV5kZkFZhZER4dq1a4sWLWprayMQCJzXnDRpUnl5Of5vqb6+3sjISEdHJzY2tn+bxOWeraysEhMTm5qaut1hRETE0qVL29ra+q+NCIIgCIIgSCdYLNbly5dDQkIyMjLU1dW/+uorQ0NDOTk5LvsbRqba2trCwsKXL18+ePDg8+fPtra2u3btmjBhApebCw5o4xCET2APaLqNWjvdsK2tbSCiwX7fM4GAnkMhCIIgCIIMuLS0tPXr1z979szZ2fnChQtUKpXXLRpimpubb968efDgwcmTJ7u7uwcFBcnIyHS7FRoqjCCcSEhIfPz48c6dO0NozwiCIAiCIMgACQkJmTp1qqCgYGpq6rlz51DU2gskEsnR0TElJeXXX3+NiorS19dPTk7udivU44ogCIIg/I3BgIwMKC2FujpeN2Uok5CAUaNAXx/IZF43BUGQIam5udnd3f3SpUuHDx/28PDoxVA+hB2BQPj+++8XLFjg5OQ0e/bss2fPLl26lMP6KHBFkC5FR0cvWLAAe93Y2IhPWsjMzPT19X348GFLS4uhoeH27duPHDmSkJAAAKtWrVJTUwsICAAAU1PTxMREAIiLi5s7dy4AyMrKlpeXc7NnJpM5efLk4ODgQT1hBEH4SlUVXLwIUVGQlARMJq9bM1wICoKpKSxYACtWAIXC69YgCDJktLa2LliwIDEx8datW9j3OqRfSEpKRkVFeXt7L1++vL6+3tXVtas1UeCKIF2yt7dnsVj29vY3b97EF3748MHExERMTOz69esmJia5ubleXl6vXr0ik8l4CiV/f39xcXF8kzlz5rBYLGNj45ycHO73/OnTp82bN3/8+HEwThVBEL7y+TPs3w8HDgCRCPb24OYGkyeDigpISPC6ZUNZXR0UFsLLlxAXBwEB4OcHW7aAtzeIivK6ZQiCDAEbNmx49OjRo0ePpkyZwuu2DDdEIjE0NFRCQuKnn37S0NCwtLTsdDU0xxVBesbPz6+6uppGo1lbW4uLixsYGFy5cqWhoaHf9zx+/Phz586hCjcIMuJERYGeHhw+DIGBUFgIFy/CsmWgq4ui1r6SkABdXVi2DC5ehMJCCAyEw4dBTw+ionjdMgRB+N2pU6eOHz9+4cKF3kWt/FZzkT/t2LFj4cKFjo6OHz586HQFFLgiSM/ExcUBwDfffIMvkZeX19XVHYg9Kysra2tr933PCNK/wsPD8Zps7IML+EfvviJ0WjzZ19cXP9np06cPQGPZsFjg5wfffQeWlpCVBVu2oGB1oEhIwJYtkJUFlpbw3Xfg5wcoKzuCIF2g0+lbtmzx8/NbuHBh7/awefNmFos1ceLE/m3YMEMgEM6ePTt27Nh169Z1ugIKXBGkBxgMRl1dnbCwcLsv65Q+T5Tqas8KCgp93DOCDJCTJ0+yWKz6+nrsx/r6+nHjxtna2vK2VZhOvyJ028IlS5awWKx2I5RCQkJYLBaLxSISiQPVXExjIzg6QmgonDsHZ8/CqFEDezgEAEaNgrNn4dw5CA0FR0dobOR1gxAE4Ufe3t4KCgrbtm3jdUOGP2Fh4ePHj9+7dy8mJqbjuyhwRZAeIJPJEhISTU1N+Jd1TGlpabs1BQQEmpub2ZdUV1f3Ys+VlZV9azKC/J+4uLiZmdkA7Xzgih73F75uYVsbODvDw4cQHw/ff9/lao2NcOMGuLuzJk8GCgWIRCAQ0H+d/0ckAoXCmjwZ3N3hxg1OQen330N8PDx8CM7OwJ+/HgiC8M6LFy+uXLly8OBB9sE4yMCZMWPG0qVLN23a1Nra2u4tlJwJQXpm7ty5kZGRcXFx+HCR4uLirKysdqspKSkVFhbiPxYXF+fl5UlKSvZoz+Xl5e/evevX5iPIQMFKE/O6FZzwdQv9/SEmBu7eBXPzzleoqYHgYDh1CurqmBqqzWOVWnWms8SEWagYQxcILBahoYlYVkV6ECd45gxISMCaNbB1K0hJdbK2uTncvAlWVhAQAHv2DHpjEQThX0ePHjUyMsKLQSCDYOfOndra2nfu3LGzs2NfjgJXBOmZvXv3xsfHe3l5SUlJmZiY5OTkbNmyRVFRsbi4mH21r7/++tixY8eOHVu5cmVJSYmfn5+CggKedpibPefl5W3cuFFcXLympob75rW0tAgJCfXy3BAE4YkbNyAkBM6dg6++6uTdtjY4dw58fVnNTQ1fGTeZTGyTFBv0Jg5tArUNwsnpYiePE379FUJC4IcfQKDDiDMzMwgLgx9+ACoVHBx40UwEQfhOU1PTjRs3Dhw4wGGdgwcPbtmyBQBUVFSioqJ8fX2fP3/e2to6bdq03bt3m5qadrUhk8n8/fffz5w58/r165qaGi0trdWrV3t4eAh8+QPFYDD27NkTGRmZl5cnLCxsamrq6uo6b948IpHIXlgxJyfH29v7zp07JBLJxsbm559/rqmp8fDwePTokbi4uK2t7aFDhyS+ZEzo9qD8QEtLy8LC4rfffmsXuPJRExGkp969e/fXX3/1S0Zf+JLNJT09vbCwkEAg+Pv7R0dHEwgErGKNiIiIk5MTAGhqaiYnJ0+ZMmXhwoWjRo1yd3ffunWrlpZWu73t3r179erVe/fuVVBQWLlyJRbcVlRUEAgEX1/fbveMbeXh4TF+/HgGg0EgEFavXs3NWZBIJBkZGQMDA2tra3d398DAwNOnT8fHx2dkZPTXhRquysrK1q9fr6amRiKR5OXlHRwc/v77bwCorq4msNm9ezcAMJlMfAnWQ85kMiMiIqytrRUVFUVERMaPH0+j0fBRqey5gl68eGFpaSkhISEqKvrVV18lJSWxN6OiomLjxo2ampokEolCocydO/fhw4fYW9ivDebdu3eLFi2SlZXFfiwvL+emAQ0NDUlJSdgmgoKC3Z4799jbhj+gYTAY27dv19XVFRUVlZGRsbOzi4mJ6Tjyp51+ueBcthAAMjMz7e3tpaSkxMTEzM3NsdrLg+rzZ9iwAVau7HyEcHU1fP01uLs3jlcv3+72+ZsZKGrthTZJsc/fzCjf7tY4Xh3c3eHrr6HTuRvffw8rV8KGDfD586C3EUEQfvT06dOGhoZ24VM7eFaF6upqT0/P3bt3FxcXP3nypLKycvbs2Y8fP+5qw7i4uCVLlsyePfvt27f5+flubm4bN2708fHBV1i3bt3PP/989OjRioqKt2/f6urqzp8//+nTp/ClsOL8+fMBYOPGjd7e3sXFxUeOHAkPD1++fLmXl1dQUFBRUVFgYOCZM2d27NjB/UH5hJ2dXVxcHOu/afMILJRGDxmyLly4sHLlSgAYNWqUjo6Ovr6+jo6Ojo6Otra2mpoaeyaVyMjIxYsXD9xvu5WVVWJiIucO1YGGnWNkZGRhYWFeXl5hYWFBQUF+fn5RURGTycTWUVRUVFVVVVZWHjt2rIqKioqKypgxY1RUVFRVVclkMg8bz3NFRUUmJiZNTU1nz56dOXNmbm7uTz/99OzZswcPHpiYmADA3Llz7927l5WVpampiW81Y8YMDw+PpUuXAkBsbKydnd3evXvXrFnT2tr622+/eXl5bdy4kf0x7aRJkz58+DBhwoTQ0NAJEya8fft21apVmZmZ9+7dmzVrFgAUFxfPmDHj8+fPZ86cmTlzZnFx8datW6Oiok6fPo0/ucDK/86aNSswMHDq1KmvX782NTUtLi5OSUnptgHi4uKTJk1qF5t1e+4dhYeHOzs7nzx5cs2aNezLsbY1NjZiE4FcXV2vXbt27do1MzOz2tragwcPHjx48OHDhxYWFt1+Iv11wcvLywsKCrpq4YcPH6ZMmSImJnbu3Dm8eHJWVlZRUVHHf86CgoLGxsYpKSndNr5nduyAw4fh3TtQUmr/1sePYGPTVlFa7ebAHK3Yz8cdqQTzi6XDbgjIycOdP4Dtt+tfpaWgrQ1eXhAYyIPGIQjCZ0JCQk6cOJGXl9ftmpMmTUpPT//rr78mTZqELXn9+vWECRMmTpyIPwtud1eKjY0NDQ3FH08DgLOzc0RERHl5OTa5TENDQ0lJif0Bt46OTlhYGH4bxW5qt2/ftrGxwZYYGhpmZGQ8fvx45syZ2BINDQ0SiZSZmcnlQflESkqKiYlJdna2uro6vhANFUaGMPxPQ0lJSUlJyZ9//gkAWJAmKCg4evTo8ePH6+npjRs3jn266fDm6OjYcWFVVVV2djadTi8qKsJevH37NiEhIScn5/OXjgUKhaKkpKSsrIz9lcRfjBkzRmIEFOTYunVrbm7u5cuXsT/9BgYGV69eVVNT8/DwSE1NBYDNmzfHxcUdOnTo+PHj2CZJSUmFhYXsF9zCwmLr1q3Yaw8Pj+fPn9NotICAAPY7QUNDw4kTJ7BfXWNj4/Dw8AkTJnh6emJ3ta1bt3769Om3337DMt9KSkpeuXJFQ0Nj/fr1dnZ2o9jSzPr4+GD3rWnTpuEPJrhpQC/OvdcSEhKwzn8AEBEROXDgQKdJAjvVXxecM6x48pkzZ7BGYsWTNTQ0uNy8H1RVwcGDEBjYedQ6bRpTQrh684o2KX6sOTREMUcrVm5ZIR32u+C0afDsWfvYVUEBtm2DwEDw9IQ+p4tHEGSoy8nJGTduHJcri4mJ4V9NAWD8+PHKysrp6elFRUVKHf/IA9ja2rZLdD9x4sTw8PCMjAzswfGcOXNOnjzp5ubm4uIyZcoUIpHYaeoTY2Nj/LWysnJGRgb7EhUVlfT0dO4Pyiewy/7p0ycUuCLDhL6+vpCQUEtLC/Yj/vUde/3p06ecnJy7d+82Nzdjfa1btmzZs2cPiUTiTXN5h0KhUKlUKpXa8a2qqir2gBZ7kZiYmJubiw8txmPadpHtuHHj+OrhXF9ER0cLCAiw/ylXVFQ0MDBIS0srKChQVVW1tLQ0MjI6f/78rl27ZGVlAeDAgQNeXl74gFsu7wSc72pRUVEAMG/ePHwFMplsaWl56dKlu3fvrlixAl8+derUdqfQ61tRt+fOYVvOuLzjdqq/LjhnXRVP7phubaBcvAhEIvy34xoAoLoabOYyJYSrvJaxSGjWej9rkxKv8lpGOXJF0GYuPHsO0tL/eXvNGggKgkuXYP16HjUQQRB+UVNTI9VpRrfOSLf7YwKgoKBAp9NLS0s7DVxrampCQ0OjoqIKCgrYa0/gnQrHjx83MTG5cOECVqfN3Nzc3d29Y5oo9i9jAgICRCJRVFQUX0IkEtnn0XR7UD6BXfZ2JTlQ4IoMYUJCQjo6Ov/8809XK7BYLCysHTdu3Pv370NCQvq9EuPVq1exgYsAQCAQVq1adebMmf49BJdaW1vZZy1yiUKhUCgUAwODjm91GtOmpaXl5eXhNXuEhYU7dtIqKytraWlx/4ee5xgMBpYBq9M2v3//HgveNm3a5OTkdOLEiYCAgKysrCdPnly6dAlfjcs7AYe7moyMTE1NjbCwcLsubqyjtV32LzGx9hMde3cr4vLce4fLO25X+uWCc8ChePLgBa5RUWBvD+0GNbS1wcLv2irKqjevQFHrAGGRhKrdv5M5cFHgu+/g/v3/5GqSkAB7e7hxAwWuCIL06MtVRUUFi8UisCV7x8olKigodLq+nZ3d06dPaTTa0qVL5eTkCATCkSNHNmzYgE9tIxAIzs7Ozs7OLS0tjx49OnjwoIODQ2ho6MaNG3t9Rt0elE9gl529UwpQciY+wZ64hddtGRpYLFZ2dvbvv/8uLi7OIYmuoKCgnJzc+fPnT5w4AQA9Ss/LpSVLlrDY8CpqBYDq6ur+jRWxgNbKysrNzS0wMDAsLOz+/fsZGRl1dXWVlZX//PPP/fv3aTSas7OzhoZGUVHRrVu3Nm/e/O233xobG0tLS4uIiGhqalpbW69YscLX1/f06dO3bt1KS0vjXM+WJ8hksrS0tKCgYEtLC6uDr74kel28ePHo0aOPHTvGYDBCQ0NdXV3ZI0w7O7ugoCBXV9esrKy2tjYWi3X48GEAaHcnwO5q7EvwuxqZTJaSkmpqaqqrq2NfoaSkBAAUFbuZ4shNAwgdSqdwee69g91x4+Pjq6uro6OjWSyWg4PDoUOHuNy8Xy44B7wvntzUBH/+CXPmtF9+7hw8elzt5oBGCA+oNinxancHePwYzp1r/94338CffwKDwYt2IQgyVDU1Nb148QL/8fXr13Q6feLEiZ12t7a2tiYlJSkqKq5fv15eXh67QTf+t+K0tLQ0NjdVSEjI2toayzJ4+/btXreQm4PyMxS48gU8HRmvG8K/Wlpa/v777/Pnz3t5eVlYWFAoFE1NzUWLFuXl5XX6PZVEIpFIpE2bNn38+HHFihXYpLXB60XhhXZpbAZUVzFtbW0tHtOGhYW5ublpaGhUVVXFx8dv2bIFi2kpFEpXMS2dTh+c9nfk4ODAZDLbJfjdt2/fmDFj8Kd9goKCnp6epaWloaGhV69eXc/WG8P9nYDzXQ3rjWS/JzEYjISEBBEREfbhrB1x2QBRUdHm5mbstY6OzunTp7k8997p4x23Xy44Z3PnzoUvA4Yxg1o8+e1baGkBI6P/LKytBb+tn2dRUTamQcAcrfh5FhV8fdsnGZ48GVpa4EsuEwRBEG5ISUn5+fklJyc3NDSkpqY6OTmRSCQajdbpykQi0cLCori4+MCBA+Xl5Y2NjQ8fPjx16lS71dasWfPq1SsGg1FaWrp//34WizV79uxet5DLg/ItFLjyNXFxcTMzM163gjfq6urS0tIuXrzo6elpZmYmJSVlZGTk5uZ2//79MWPG7Ny58+nTpzU1NREREe2+W2ODga2srN69excSEoINAlRXV6dQKMnJybw5mUHx7Nkz9smTvILHtCtWrPDx8QkLC7t161ZqampNTc3nz58/fvzYMab19vbGYloVFRUspjUzM1u0aJGvry+NRrt27RoW0w7oIJbg4GBNTU0XF5c//vijpqamsrIyLCxs165dBw8eZB8j5ObmJiUl5e/vb29vr6Kigi/n/k7A+a4WHBysrq7u5eUVGxtbV1eXlZW1bNmyoqIiGo3GnpmpIy4bMHny5KysrPz8/OTk5OzsbHNzc+7PvXf6eMft+wXnbO/evTIyMl5eXvfv36+vr3/z5o2Tk1O7kcMDqKgIAGD06HZtYjU1NtiM0L/8g6/BxozV3AQhIf9Zio1+wj4gBEEQ7oiLix89enTnzp1KSkozZ86kUCgPHjzAqgZ0rLkIABEREe7u7kePHlVWVlZXV7948eKyZcsAwNraGsuu9PjxY11d3SVLlsjIyOjp6cXFxf3yyy9+fn4AkJKSwl5Y0d/fPzU1lUAg3L17t7W1lUAghISEJCYmEgiEx48fNzQ0EAiEwMBAbg7Kz1A5HD7SsXJDp7UrhquqqqqMjIy0LzIzM9va2qSkpAwNDalUqoGBgb6+/pQpU9pVbamrq5OSksJ/jQUEBPT19Y8fP44nAcctXbq0pKTkwYMHg3Q+g6u4uFhFReX69evcTyDkK42Nje0m02IvPn78iA8txubTdpr6WElJqeMg2J6qrKzcs2dPdHR0fn6+tLS0kZHRli1brKys2q3m7e194MCB9PT0CRMmsC8vLy/39/e/c+dOcXGxjIzM3LlzFRUVQ0JCAIBKpWLpebF/4/fv39+wYcOff/7JZDKnTp26Z88e9urkFRUVu3fvvnnzZkFBgaio6PTp0729vbFgD0sNz35Q9j/g3DTg3bt3rq6uL1++lJGR8fX1Xbt2bY/OHdexHA57JXQAWL58eXh4eHp6+smTJ588eZKbmyssLKytrb1q1apVq1b16MPq3QVfsmQJVg4es23bNmNj444tBICsrCwfH58HDx60tLQYGhru2LHj8OHDCQkJANBuynr/l8O5dg0WLYK2NsAvSGMjKCnVWxh9/mZGvx0F6Y7o3T/FH/8NdDqIiPy7iMUCAQGIjITO8rQjCDJyLFq0CAAiIyO7XbPj13ikjwgEQkREBPYR/LsEBa78Y6QFrnQ6PY1NUVERACgpKeFhKpVK1dfX7/Y77tixY/Py8gQFBSUkJPbv3+/i4iIg0MlQgpiYGHt7+6ysLC0trQE5H54KDg4+ePBgQUGBCP7Fa7joKqbF/o+tQyaTVVRUOo1pFRUVO/194Ilhc1frqo7r8Nb/gWtkJCxeDOx34Rs3wNGxfK9Hm2T75Fvs3hdX7I5+mJSV29Laqqssv9nGPOzB86fvcgBg2YyJh53mMdvabv+VGZ6U/pZeWtvIUJenOJlOWmVhLPDlz2kzs/VwXFJM2tuCyhphIcEpmqrOpkZWhlpEgb4+ABqKBGob5PyOwvXrwP7gj0CAiAhg+8KEIMgIhAJXHuoYuKKswj3D3quQk5Pj7e19584dEolkY2Pz888/19TUeHh4PHr0SFxc3NbW9tChQ+ypRMrKyoKCgmJiYuh0upSUlLm5+fbt27sa23nw4EGsuyApKQmL3IhEYh/nm/FWS0tLVlYWHqamp6fX19cTicSxY8fq6+u7ublRqdRp06Z1lXiNgylTptDpdE9Pz4CAAA7ZiebNm6epqbljx47Lly/37VT4TlVV1eHDh11dXYdf1AoAIiIiGhoanZbWbGpqotPp7QLa+Ph4Op1eXFyMPZUjk8kyMjKdpj5WU1Pjn5gWQQAA7t5laqhyjlo/lVXNO3BBlCz0q6uDsYZKQWWN/7X4N4WlJEFi/s8+2DoPM7Ldfo32m2/xy+oFbW1tN1LfBFy7T6+q3eFgia3gG3H31su3Z1Y7TNMaXdfIOBGfsuLUtSiv5TO0xw74OfKfNkkxpoaqYFwcDM0RKwiCICMEClx7xt7ensVi2dvb37x5c+PGjX5+fmfPnr1x48aKFSsqKipIJFJQUJCWltbly5fXrFkjISGB588sKioyMTFpamo6e/bszJkzc3Nzf/rpJxMTkwcPHnRacnDz5s2bN28e0j2utbW1r169SktLe/PmTUZGRmpqKoPBIJFIWlpaVCrV0dGRSqVOnjyZvdJU76xatWrv3r3a2tqcVyMSiaGhofb29u7u7h0HEg9pgYGBBAJh69atvG7IYBMWFu5RTJuUlMQe05JIJFlZ2U5j2rFjx/Z75aTh58cff/zxxx/FxMTaZeUdZnx9ffft2zc4x2I9e9Y8tpPkk+z23nxU09h0yMlmlp46AOgoyZ9ymU/1P95utRnaYz2/jDdebWH8Vw79l4cvNtqYSQiTAeBpZo6Okjy2B2EhwR0Olndfve//8xk6mscoEtNSR2J3M4IgfYb3NgEAgUDYtm3b7t27eduk4QoNFe4NLHC9ffu2jY0NtsTQ0DAjI+Px48d4RKShoUEikTK/5CRcuXLlhQsXLl++jE2ABoDi4mI1NTVDQ0Ns7hkM/aHC2NBfLExNS0t7+/Yti8WSlpY2MDCgfqGrq8vbeGDOnDklJSXJycnCwsI8bEY/evny5bRp006dOrVq1Spet2VoYDAYhYWFHUvU0un0kpISrEh3v8e07Hc1AEB3NQ5TAHbs2IElkBj+Og4VplDq5kxvnDmZw0aaGw/WNzVnH94sRibhC62Dz2YWleE9rh2diH+280bC7c3fG2uoAIDP1bjzT146mU5aNmPipLHKI3OEMDuRJy8l7qZAZYv17UgAACAASURBVNX/F6GhwgiC9GSoMNLv0FDh/sSeektZWTkjI4N9iYqKSnp6Ov5jdHS0gICAra0tvkRRUdHAwCAtLa2goGAolm9tbW3Nzc3F0ym9ePECqzaJTVJ1dHTE5qkaGBjwuqX/cezYsalTp7q4uFy+fLnv6Xx4jk6nz58/38LC4ocffuB1W4YMMpncVT8te0yLB7RpaWmxsbE5OTlYTCskJCQnJ8ceyuKR7ZgxY7pKw4uNoRjYExtS0DPTztXVsUTJHN5vZrbWNzWThQTZo1YAkBL9z5O42kbGyYRnd/5+V1RVV9PYhC9vbGnBXoQsnmOsrhqR8uo72hUAmK41eoWZkc0knX47kaGGJUqG2rru10MQBEF4BwWuvScpKYm/FhAQIBKJ7KNeiUQi9jUXABgMRk1NDQB0OgPz/fv3QyJwbW5ufv/+PT5J9a+//vr8+bOgoKC2tjaVSt2wYYO+vr6JiYmcnByvW8qJlpbWtWvX5s6dq62tPdR7dRoaGubPny8uLn7t2jU0V7NfcIhpm5uby8vL23XSYjFtbm5ua2srthqFQunYScs5pkWQ/2ttZRE4/VsmCRLFhUn1Tc0NjGb22LW87jP7as4nI1M+5O92tHaYYiAjJkogwOkHzwOux+PPCwgEcJxm6DjNsKW17c+s3BPxKT+c/n3nd5ZrLKcNxGnxPxZBAL78K0YQBEH4E/oiNRjIZLK0tHR9fX1jY2OPvrzytkuwurr6n3/+wSPVd+/etba2SkhITJgwwcDAAJukSqVSh1xCIEtLy+PHj7u7u9fV1e3fv3+ITmXE+lpzc3OTk5OlpaV53Zzhj0QiKSsrKysrU6nUdm91GtNmZGTEx8dzE9OOHj1aSEho0E8IGaosDTRvpr198CbbzkgXW1Ja2/CxtAJfobWN9fxjgYKkmOtXU/CFjS3/ye03blPonS0rxynKChEFZumpT9Marea1//4/H0ds4IogCILwPxS4DhIHB4ezZ88mJSVhZYgx+/btO378eHZ2dlfRrKioaHNzM/ZaR0dn06ZNbm5uA9dIvD4NNk8Vm6RKoVD09fWtrKx8fHyoVKqent4w6NxzdXUVFxd3cXF5//59eHg4e+f5kPDy5UusrzU5OVlTU5PXzRnpOMS0LS0tZWVlKKZF+pHftxaPM3MCrt2XFCYba6jkV9TsvJGgICleWvtviiyiAGGG9tjEdznH76csNZkgSialfSq88PRlu/14//bHnkVfa42SrW1sOv/kJYsF5jojMaUwgiDI0DK0MuD0LxS4DpLg4ODHjx+7uLgcO3ZsxowZra2t165d27Vr17lz5zj0wU6ePDk5OTk/P7+goCA7O9vc3Lwfm8RkMt+9e4eHqSkpKeXl5cA2SZVKpRobGyspdZPicohaunSpmpraggULdHV1g4ODV6xYMSSmvFZVVQUGBp44ceKrr76KjIxEfa18TkhIqKuYFgCqqqraZYfKzs6Oj4/Py8vDa19RKJRO69OqqamJiXEqmoIMV2rylDtbvg+KerDqlxvMtjZD1VHb7C32xz6tqP//aOFfVtkH33p85lFqcMwjaTERS33N76YY/Hw32fHn3yaOUbzn6xK9wfn80zS3X6MLKmvIQoKaCjKHltssm9F5eTYEQRAE4Qe9CVxLSuDRI0hPh5ISqONRLgMBAZCWBg0NmDwZzMxg0BLEpqSk4NVrREREtm3bZm9vP2XKv8OxCARCcHCwmZkZHmESCAQsQ6aCgsLz58/37Nmzbt26/Px8aWlpIyOjmzdvWllZQdd5tI8cOeLq6qqnpycjI0Oj0fT09PrS+Lq6uqysLDyd0suXLxsbG4WEhMaNG0elUv39/alU6qRJk8TFxftylCHExMTkzZs3AQEBq1atOnHixKZNm+zt7UkkUvdb8kJxcfG5c+cOHz5MIBBOnTr1ww8/DIOu7xGOQqFg4+07vtWXmHbs2LEj51/xyKSpIHPefSH7ktKaehnx/8/akBEXPbB0brutts3/Cn9toKrQcQUEQRAE4Wc9KIfDZMLVq3DqFCQnA5EImtptioqtYuK8yQzZ1gY11QI5n4j0AoKYGDg4wPr1wJbTFwEAqKqqwsPUtLS0zMzMtrY2SUnJ8ePHU6lULOvvlClTyGROSSxHglevXm3fvj02NlZUVHT27NlGRkaqqqr8MH64tbW1srLyw4cPycnJz58/l5aWdnV13bp1a6dZvpARomNMi73Iz89v+ZIztquYdsyYMRISErxtP/J/HcvhEAg1qxYwqJyeUZbWNpjvCvtnn5cQ8d9HV/kVNdN3nFw41ZC2wpbDhggH5LS3Ur9GtfssUDkcBEH6txxOWVlZUFBQTEwMnU6XkpIyNzffvn37pEmTACA6OnrBggXYap8+ffLx8bl79y6RSDQxMaHRaNi8sHal9QCASCTij7O53HlmZmZAQEBCQkJlZSW2Fd/mVe1YDofbwPXRI/BYD+8y4Wub5gWLm01nMUVE+KKYQRFdICFOKOIS+Z9XxOXLYd8+UFbmdZt4B5+kiikqKoIvQ3+xMJVKperr6w+JMbGDr6CgICYm5sGDB69evSopKamtreV1i0BAQEBaWlpDQ2Py5Mlz5syZO3fusCk/iwyEqqqqTuvT5ubmNjQ0YOt0jGmx/48bN44fHtaMLL0NXMf70paaTPC2nUkRE8mkl22NvPeprOqezw9j5dDcgV5CgSuCIJ3qx8C1qKjIxMSkqanp7NmzM2fOzM3N/emnn549e/bgwQN8OKe9vf3Nmzfnz5/v4+MzYcKE5OTkb7/91tDQ8Pnz5/h+Op3jyv3OZ82aFRgYOHXq1NevX5uamhYXF8vJyc2ePTs9Pf327dvTp0/v+5n2l97Uca2vBzc3+O03sPym5ejZz+qabQPZwh5TUm5zcmE4uTDuxgrt3S6qoyNw4ACsWcPrZg2KlpaWrKwsPJ3Sy5cvKysriUTi2LFj9fX13dzcqFTq1KlTR40axeuWDg2qqqpr165du3YtrxuCIL1EoVAoFEqnxZM7jWkTExPz8vLq6/9N6iMsLNyxk1ZZWVlLSwt18vMPBUmx657Lzj5O+/bQpeKaemlR4Zm66qd+mI+iVgRBEH62devW3Nzcy5cv29jYAICBgcHVq1fV1NQ8PDxSU1PZ11y9ejUWbVpZWc2bN+/69evl5eWc+0W537mPj4+FhQUATJs2De+tbWtrY7FY/F9ivZvANT8f7L6FwkLWuYiGr6xbBqdNvfONbYuFde3xQ8Jr1wq/eQOHD8PQrHLCSW1t7atXr/B0SmlpaU1NTSQSSUtLi0qlbt++nUqlTp48mb2cLIIgCPQ8pk1LS8vPz6/7ksagq5hWU1MTZQgbfOY6auY6arxuBYIgCAIA8M8//4wfPx7/8aeffjp27FjH1aKjowUEBGxt/z+nQ1FR0cDAIC0traCgQFVVFV+OZ88BgNGjRwMAnU7nHLhyv/OpU6d23PzRo0ccT5FfcApcMzLA2hokpVuj79erjuGvjtZOkcmsjVsbdQ1aN60V+/ARoqOAX/PscItOp+MxalpaGlafRlpa2sDAgEqlYn2qurq6Q7QSKYIg/KBHMS32R+n9+/f4WPquYloNDQ0KhTK4p4IgCIIgg83Q0LDbvkoGg1FTUwMAnY5gev/+PXtsyb4OljS0rY1TINajnQ/pkgRdBq6lpTDPFlTHMs9F1ItL8HvHMTubb5tVVNucFoi7uxPOneN1a3qitbU1NzcXD1NfvHhRUlICbPVpsHmqaJIqgiCDg0NM29jY2HEy7Zs3bz58+IDdPuFLTNtpmijlkZyNAEGGjvDwcGdnZ+y1mJgYPrOAf+DpalRUVAoKCrjc6urVq0uXLgUAMpnc1NTU7frPnj3bvXt3WlpafX29oaHh4sWLnZ2dZWRk+tLygdC7q8FD/fjx+fr67tu3D3s9bdq0lJSUAWhv75HJZGlp6fr6+sbGRg6FMLnRMQrox53zuc7LaTQ1gb09sFhtYReHWNSKmTiZefxcQ3g4hITwuikctbS0ZGRkXLx40dPT08zMTEpKSlNT08HB4dq1axQKZcOGDTExMWVlZXQ6/datW4GBgVjsiqJWBEF4TkRERENDw8rKasWKFT4+PmFhYbdu3UpNTa2urv78+fPHjx/v378fFhbm5uZmYGDQ2NgYHx8fGBi4aNEiY2NjFRUVERERTU1NMzOzRYsW+fr60mi0a9eupaWl0el0/p9jMxI0MJqn7zjpdKJ/Emki9fX148aNYx/Fx8+77ejkyZMsFguPWgftuNzYvHkzi8WaOHEi+8JuW7hkyRIWi2VpacnNIZKSkszMzNra2pKSkoqKijw9PX18fLy9vbls4WBerk6vBj/rx48vJCQEm6XJt+MQHRwcmExmUlIS+8J9+/aNGTMGn2vKDVFR0ebmZuy1jo7O6dOn+3HnfK7zoHznTnjzhnXjXr2M3FD9AjFzdsu2oM/btolaW0NnVRJ5o7q6+p9//sHTKb1+/bq5uVlCQkJbW1tfX9/R0REr6igiItL9vhAEQfgSFtNqaGh0fKvTftr4+Pjs7OyqqipsHQ79tEpKSujJ3eBgsaCNxWr770MEda8DhqNH3dq0gletGrpYLFZbWxvnwX78s1u+PS73+reFZ86cYTKZR44cUVdXB4DFixc/efKEwWDwpDEjwXC9YsHBwY8fP3ZxcTl27NiMGTNaW1uvXbu2a9euc+fO9aibdPLkycnJyfn5+QUFBdnZ2ebm5n3fOX9mFe6okzP5+BEOH4ZtQY2a41oHv0H96Ad3xt1YkoeHYFIS8OqrDl6fBpuqik1SpVAo+vr6pqam69evp1Kpenp6AgKdd30jCIIMJ93GtO2m1MbHx2MvsHXIZLKKikqn5XzU1NTQH9J+JC5Mer4LpVjvNxISEh8/fhwqu+Xb43Kvf1uIDQMpLi4eN24ctuT48eO8asxIMFyvmIKCwvPnz/fs2bNu3br8/HxpaWkjI6ObN29aWVkBQEpKCl63RkREZNu2bbt378af1RoZGc2bNy82NhYAjhw54urqqqenJyMjQ6PR9PT0erpz+PJbjWMymUM1q/CGDaCm0bpsJbdPkvjZ9r2f7WZLXr4MTk6DcTgmk/nu3Ts8ndKzZ8/KysqAbZIqlUo1NjZWUlIajNYgCIIMHRxi2qamJjqd3mlMW1xcjN1oyWSyjIxMp5NpBz+mffHixfv37xcvXsy3I9YQBOGeg4PDhQsXPDw8EhMTxcXFed0cZAiTkZEJDQ0NDQ3t+Nb06dM7xo2dRpI6OjpPnjzp+87ZdbpDPtT+Xp6RAbdugW9g4/CY2as/vnXB4uaQfQO1//r6+rS0NHySqqSkpKGh4fLly7FJqtu2bbt//35FRQU+SdXOzg5FrQiCID0iLCysoaFhZmbm6Ojo4+NDo9EiIyNTU1PpdDo2n/bp06eXLl3y9PQ0NTUFgKSkJBqNtnjxYnNzc01NTREREWVlZWNj40WLFnl6eu7bt+/atWuJiYnZ2dmtrQMysCgtLW358uUaGhq//PILPhNpkFXUf94WeY/qf1zVI0TP+8gPp3//p6AEe8su9OKotXux/9aejwGAhbQr+JKaxqY/0rPwHxktTAA4Ef9s1Nq9n5tbnn8swJYrrwvmyXkNRdHR0YQv2PMAVVRUbNy4UVNTk0QiUSiUuXPnPnz4sOMmOTk5ixcvlpaWlpWVtbW1xXuiOt2ttLQ0oQMBAQE87U1ZWdn69evV1NRIJJK8vLyDg8Pff//d99NhMBjbt2/X1dUVFRWVkZGxs7OLiYnp9t9XdXU1ezt3794NAEwmE1+ycOFCbElERIS1tbWioqKIiMj48eNpNBqHcaRdXfDMzEx7e3spKSkxMTFzc/PExEQuT1lTU1NSUjI9Pf3bb7/lJpNTt43p3eXC9PRqcHM4Dr+KHAyVjw8ZTtoHrmfPgppGm4UVX5ds7ZEVq5oy/oHnz/tnb1VVVYmJiTQabcWKFQYGBlJSUsbGxh4eHmlpaVQq9ciRI0+fPq2trcVTLllZWfFh0jkEQZDhgUNM29jYiMW04eHheEyblpZ2+vTpJUuWYDGtqKjoQMS0BQUFQkJC+fn5a9asGT169JEjRz5//tx/J929kpr6r0PO3Xz5dt+SOe8ObozesLy6odHmwIXU7EIAuLVpxQO/1aIkIQNVhYPL5gLAlZ8WT1ZTDnOxLznhJyUiPHeidskJvzkTtPEdrrWaVnLCT5QkNFVTteSEX8kJP/qxrfi7Dkcu62w5nPapcDDPcQixt7dnsVjz589nX1hcXDxlypQrV67QaLTy8vJnz56JiopaWlqeOXOm3SZeXl5eXl6FhYUREREPHjzAkql2tVsAqKurY32xa9cuANizZw9WDKOoqGjKlCmRkZEnTpyorKx89OhRZWWliYlJcnJyH09n3bp1P//889GjRysqKt6+faurqzt//vynT59y3pW0tDSLxZozZ46AgMCHDx/8/f0BQFBQkMVimZiYXLly5fr16wAQFxe3ZMmS2bNnv337Nj8/383NbePGjT4+Pj1q4YcPH0xMTFJTU69fv15SUnLixImgoCBuxqM+fPhw6tSpu3btmj9//sOHDx0dHfFUN7a2tu2CtAG9XJieXo1uD8f5V5GDIfHxIcNM+37VW7Ew1655OCW/mGDUOnpM261bAp2V2+0ePkkVm6eanZ0NAEpKSgYGBlZWVj4+PlQqFdWnQRAE4TdkMrmrsccMBqOioqJdmqi0tLTY2NicnBysK0BISEhOTq7TNFFjxozhnOsiPz+/ra0NixxKS0s3b968c+dOT09PT0/Pwaltu+fmw4LKmpM/zLcy1AQAHSX5sFULqP7H/CLv3vN1AQADVQXaClvXM1Hrzsf86vrd5it3zHXV7I31e3c4FosFQ2BuFH/ZunXrp0+ffvvtNyx1qqSk5JUrVzQ0NNavX29nZzdq1Ch8zdWrV2OT06ysrObNm3f9+vXy8nI5ObluDxEZGbljx46VK1du3boVP2hubu7ly5dtbGwAwMDA4OrVq2pqah4eHqmpqX05nYSEBAMDA2trawAQERE5cOBATEwMl9tu3rw5Li7u0KFD+MTRpKSkwsJCR0dHfB0LCwv8LDw8PJ4/f06j0QICAiQlJbk8ip+fX3V19ZkzZ7BGjh8//ty5c53+fWBXXl6+YMECc3NzT0/PNWvW2NjYxMbGOjs7X758WUBAIDY29tOnTwYGBnV1dT2aF9CXywU9vxqcD8f9r2Kn+PnjQ4af/9x6KyrgfRb47xk+SZMx082ZySkkbtZsaWnJysrCw9S//vqroqKCSCSOHTtWX1/f2dmZSqVOnTq123/GCIIgCN8ik8nKysrKysrUDknnm5uby8vL28W0GRkZ8fHxubm5eDcshULpOJkWj2k/ffrE3mHb2tpaXV29Z8+e/fv3u7q6+vr69nrOSCa9bNbuX/AfXWZRgxd/03G1P9KzBAgE6/Fa+BIFSTFdJfn0vGJ6dZ2ytAQAfDtZL2NO6ZG4JLvQi9Jiwkece1+rI2rDoKSRGF6ioqIAYN68efgSMplsaWl56dKlu3fvrljx/9TNU6ZMwV+PHj0aAOh0eleBa3V1Nfbi2bNn33///cyZM8PCwvB3o6OjBQQE2KuMKCoqGhgYpKWlFRQUYL2yvTNnzpyTJ0+6ubm5uLhMmTKFSCS+e/eOy20tLS2NjIzOnz+/a9cuWVlZADhw4ICXlxf+eMjW1rZdZZSJEyeGh4dnZGTg+Wa6FRcXBwDffPP/fy/Kysra2tpZWVkctjp37lxNTc3y5csBgEwm37x509LS8urVqxISElgNkkePHpmZmfV0NntfLlcvrgbnw3H/q9gpfv74kOHnP4Hr27cAANp6QzuZcEc6eq1nH3X+Vm1t7atXr/Csv2lpaU1NTSQSSUtLi0ql2traUqlUIyMjMTGxQW3xEMFN2eghVwu7K10VYY+MjFy8eDGJROI+M/7IMXIKiyPDBolE4hDTFhYWFhYW5uXlFRYWFhQU5Ofn//3337du3SopKcH6aYlEoqKiYqd/DZhMJpPJPHny5MmTJ3/44Qd/f//RPW+errJ8yQk/zus0M1trGxkAoLWxkxQdn0orscAVAHztZj3J/PQiu+Do93YCaNzQIGIwGDU1NcLCwhISEuzLscfixcXF7AulpKTw1yQSCQC6LROSl5c3f/780aNH37hxA9sEP2i7HeLev3/fl8D1+PHjJiYmFy5cwEprmpubu7u7L1iwgMvNN23a5OTkdOLEiYCAgKysrCdPnly6dAl/t6amJjQ0NCoqqqCgAI/MAYD7EfgMBqOurk5YWLhdaiUFBQXOkQ/2Lt5dIS4u/scff8yaNeuXX36RkJDYv38/jUbz8+vmn2RHfblcvbgaHA7Xo1/FrvDtx4cMP/+Z41pRAQAgKzsYdZNOHzumJiOjJiMz3cCA+61u3biBbaXdk8fVMrJtFeX/vsZqBuKTVCkUirm5eWBgYEZGBpVKDQsLS01NraurwyepmpmZoai1K9zUue5daWm+1a4IOwDIy8vj/8cN3RPsXyOqsDgy7JFIJHV1dTMzs2XLlm3ZsoVGo924cePZs2d0Or2pqSknJycxMTE8PHzDhg21tbVd7aSlpaWlpQUb5Lbq1KkPA9FOQaKUiLCggEDhMV9sPir7f6baY/E1/3yfW9fE0FNW8PktLqOgtNs9o0kx/YVMJktJSTU1NdXV1bEvLykpAQBFRcW+7Lyurs7W1ralpSU2NpY9ywaZTJaWlhYUFGxpaWF18NVXX/XloAQCwdnZOT4+vrq6Ojo6msViOTg4HDp0iMvNFy9ePHr06GPHjjEYjNDQUFdXV/Y4ys7OLigoyNXVNSsrCxuEf/jwYegi4WqnyGSyhIREU1MT++0bACorKzlviHUhvsU6dgAAQEZG5t69exoaGocOHTIxMRETE2MfE8ulvlyuXlwNDofrl19Fvv34RpqDBw9iM6778hCKz/0ncMWeEZPIg3Fgt3Xrcior9QwN2Rc2NDRYGBu7LFnS1VZ2Dg45lZWms2b16FgkMjAYD6ytreXl5VVUVKytrWk0WkNDw5IlS6Kjo/Pz89lTLlGpVPzxJDJABrO0tLi4uJmZ2cDtv9PAlT9rZw/0peASf14cBOkLISGhsWPHmpqaLlmyxMXFpdtMwm1tbUwm8+zDh1MAzp8/3+/tmWekw2xre/7xP8Mcjt5LNtp2jPnln15eRbXXpdtnXb+79KOjMEloxalrFfXddICIkISamf+OyZoReOpS4l/93vKRA+vvun37Nr6EwWAkJCSIiIiwj4fsqdbW1iVLlmRmZv7+++/a2v+m11q4cGF0dDQAODg4MJnMpKQk9k327ds3ZswYPOFQ70hLS2dmZgKAkJCQtbU1lhiW/ew4ExQU9PT0LC0tDQ0NvXr16vr169nPKCkpSVFRcf369fLy8tjTk8bGxp62cO7cufBlxCmmvLy82wG62Md0+PDhqqoqfKGSklJ8fLy0tPSLFy+srKx68UCn15erd1eD8+H6/qvItx8f/5s+fXo/dnJw05801PFZufYB/EZLUlFR2bZt28OHD6uqqrKzs3///feAgAA7O7th/FiCb2Glpe/cucPrhvSDTgPX4XSC/Q5dHGR4y8vL63Q5iUTCysnKysp+8803ISEhT3fuLAVYuXJlv7dh23wLNXmK16XYhIyPtY2M6obGi0//Cr2TGOhgKSggAAANjObvT13f7WitrSQ3WlbqV1eHkpq6VadvtLRyuv9OGD0qu7SSXlWbml2YW149Xevfwc4oq3AvBAcHq6ure3l5xcbG1tXVZWVlLVu2rKioiEaj9SWPxoYNG+7cuXP69GkLC4tOD6qpqeni4vLHH3/U1NRUVlaGhYXt2rXr4MGDnPONcWPNmjWvXr1iMBilpaX79+9nsVizZ8/mfnM3NzcpKSl/f397e3sVFRV8OZFItLCwKC4uPnDgQHl5eWNj48OHD0+dOtXT5u3du1dGRsbLy+v+/fv19fVv3rxxcnLqtijrtGnTfH19c3NzzczM7ty509DQ8Pnz56SkJG9vbzExMQqFEhQUdOHChZ42Bnp7uXp9NTgcrl9+Ffnz40P6jk/6PHD8FbiKiYs/efnyfGTkAOzb7Pz5815eXhYWFtLS0gOwf2SEkpOTIxAI7QJXBEFGrMLCf+M3AoEgJCQEAAICAvr6+u7u7pcvX87Pzy8vL799+7aPj4+Zrq7QwLRBTkLsrvfKuRN1tkbc1fc+PGNn2O2/My+uWTifqgcAWyPuamw4+KawdMWpa5n0ssr6zwsOh7e0tiV/yFP1CDn8RxJWxzXuVRYAjPHcj9V6BYAgR2t9FQXTnWGuv0btXmQ9TvHf/ECtbW0oqzAHWAfXzZs3AUBERMTJyQkAFBUVX7x4sXTp0vXr18vKyk6dOrWhoSE+Pt7V1RUAUlJS2DfBCo0QCARsqr+RkZGtrW3H3aalpR09ehQAfvjhB/YCm7///jvWEgUFhefPn9vb269bt05eXl5XV/fGjRs3b95ctGhRH0/n8ePHurq6S5YskZGR0dPTi4uL++WXX3o0+VNCQsLNzY3FYm3atKndWxEREe7u7kePHlVWVlZXV7948eKyZcsAwNra2tjYGBsemZ6eXlhYSCAQ/P39O22hpqZmcnLylClTFi5cqKCgsHLlSg8Pj/HjxzMYDAKBsHr16q4aFhwcHBsbq6am9v3330tLS6uoqPj4+JiYmGRmZt6+fVtERGTlypXYde6017rfL1dPr0a3h+P8q8glvv34upKXl3f58uV2Y48R/kdgv9VERsLixZBTWcVhg/41d+bMqoqKlIyMHm21fMGCFykpWUVFXK4fG01a5yKG7qkdMRiMPXv2REZG5uXlCQsLm5qaurq6zps3j0gk7t69OyAgAABMTU2xKs9xcXHYUA1ZWdny8nJ8J5MmTSovL4+Pj9+0aVNiYmJLS8u0adN2IXjS7AAAIABJREFU796NVU1kXwdLzxMdHY1nIGhsbBQWFmZfkpOT4+3tfefOHRKJZGNj8/PPP9fU1Hh4eDx69EhcXNzW1vbQoUP43Akmk/n777+fOXPm9evXNTU1Wlpaq1ev9vDwwLo18MxAOCKRiN9XysrKgoKCYmJi6HS6lJSUubn59u3bJ02a1NW1wpIznTx5cs2aNe3ekpWVdXZ2PnLkCPZjxxPkfKk5f0bse/v06ZOPj8/du3eJRKKJiQmNRtPU1MTXrKio2LNnz82bN/Pz88XExKZPn+7t7Y1NW+J8KTpVXV3NXrcjKCjI39+fyWRiX8QB4Lvvvrt+/TrnjwDD+dPHXmdmZvr6+j58+JDJZE6ePDk4ODgwMDAxMbFjqXdBQUFjY2OUnAnhW6dPn3Z3dxcVFZ0+ffrMmTPNzMymTZvWec8AdtNlvzkRCDWrFjCoeoPWWgRDTnsr9WtUu88CIiKgJxHdsMTh3ocg/Imb7wkvXryYOnUqmUz+9ttvnZyc5syZ09U8QeyxTuSAdKrB9OnT5eTkYmNj+3Gf7F+6+k5cXHzSpElYIDD4CARCREQE+5O1PvW4NjMYh4KDZ0+dqqusPFFDY9XSpff/+IO9BkBVZWXQtm0zJ0/WGjVqgrr6946OyV2XV753+zaWeElNRoY9JePH9+9dnZwMx47VU1FxtLF5gb6w9h8ONan9/f1ZLBZ7Yqo5c+awWKyOmTYBoL6+fu3atX5+foWFhU+ePKmsrJw9e/bjx487PWjH0tLsSzZu3Ojt7V1cXHzkyJHw8PDly5d7eXkFBQUVFRUFBgaeOXNmx44d+Iacq1pjY/3FxMRMTU2x5BN4qNYvRdhx8vLy7D2u/VttnJsy9NBdAXEOl6IrqLA4gvTOjBkz/v7779ra2oSEhB07dlhaWqLxbAiCIHyIwWBERUXZ29vLysquWrXqwYMHfJ6Ag8lkRkREWFtbKyoqioiIjB8/nkajddvmsrKy9evXq6mpkUgkeXl5BweHv//+G3sL69/GvHv3btGiRbKystiPvr6+BAKhoaEhKSkJW9L3CQV916fAdbu397mwsJ379/+dnZ3w7JnmuHGuy5e/+PLVv6y09FtLy5vXr+8IDv77w4eb8fEioqLL7O2vsuXIZvf1vHk5lZXWNjbsC3Oysxd8/fXrv/46eeFCalZW0MGDPx84kPvpU1+ajeDwmtQiIiKjRo06cOAAnsuhR2pqavbu3WtqaiouLm5sbBweHt7c3Ozp6dmLXa1atYpKpYqJiTk7OxsYGPzxxx8bN26cNGmSuLi4u7u7urp6u7mRWFVrCoUiJyfn4eGxbNkyGo3GIaUnBivCfujQIRsbG3FxcawIO4vF8vDw6EWb5eTksMSDHPTLpcbK0IuJiWFl6F+8eIF3fWMFxI8cOWJrayspKamtrX3lyhUlJaX169djuQF7Z/PmzW1tbeypDrsqLN7Tj4AdVlicRqNZW1uLi4tjhcWLuB5SgSB8xdDQcOLEiSj9NTKc/PjjjwQCAT2CQfgZFmgRCAT2LrRuMZlMrFpEeHi4paXlqFGjPD09ExMT+XPyQ097C6C7rhr27gR3d/e1a9fm5+enpKQQicRe9HkMgj4FrklPnmjr6ppbWAgLC8vJy/vt2qXONnBx365d+bm5O4KDLb/5RlxCQl1T8+fTpxVGjQr08SkvK+PyEAeCgmpranaEhJhbWIiJienq6x88fry0D1/EEXZz5sz5888/3dzcUlJSsH/n79696zSjA2fCwsLTpk3Dfxw/fryysnJ6enovYg9jY2P8tbKycrslKioqdDod/9HW1vbhw4fsm0+cOLGlpSWju8HnnIuw97TNgoKC3T6F6pdL3WkZeuzHrgqINzY23r17t0dHYYcXFq/AimV1Vli8dx8Bu64Ki/e62QjCWw8eAKrrjAwPTk5OeMmc3k0IJHQtMDCwv9s75PHb5eK39nCAl81jsVi9mE+EZYMvLy8/efKkubm5qqqqr68vlo25HwkKCrJfw2fPnt2+fZt9SbcliHraW8B9V42Pj4+FhYWoqOi0adOYTKacnFw/nHB/61Of7yxLy/CzZ7d6eS1ycppgZEQkEh++eIG/ezc2FgBmf/01voREJpvOmnUjIuJxQsJ3Xde8YfcoIQEAZrJlWhulqKihqZmNhhH2hz5WDMdh4wrYlygoKNDp9NLSUqWeVNwFAElJSfy1gIAAkUgUFRXFlxCJRPYREb2raj2gRdi70i+Xuqsy9P1SQLwrqLA4gvSUoyM0NsLXX8P8+TBvHigo8LpBSM9VAbgfPgzXr/O6IUMehzKnb9686VFeqJGA3y4Xv7Wnv3CoAdvS0gIAdDo9NDR03759kpKSampq+fn5WIdBH7XrtOzpHFdbW9t25XMmTpwYHh6ekZFhYmLS6Sacu2rYv/FOnTqV29PgnT71uAYdOHDo5Mm83Nxl8+cbjhmzYuHCu18ufTODUVdbSyaTxf77ZVROXh4Aykq7L3SO7aShvp5MJrPPtAQAWZTBtZ8QuiuBLSAg0K4gIXtwgsPiQHalpaUAoDDA39e4qWpN6FBgrd+LsD969KjbjHbdXuq+4LKAeMdLwQ1UWBxBeopEgsZGiI2F1atBURGoVNi7F1694nWzEARBkKGspqZm+/bt48ePp1AoWA8tlnqzq94CrGOjra1NSkqKvV/35cuXAPD+/Xv2ldtFW/ypTz2uBALBYfFih8WLmS0tyUlJp48edV+xwn/37tVr15LIZAlJybra2ob6evbYFRskLM9dPEMik8XExRvq6xsaGtivZnXV4OU9Ht6kpaVTUlJ0dXWxmtRmZmZiYmK3b9/euHEjtoKSkhJe2gEAiouL8/Ly2DtFMfX19enp6XjJ49evX9Pp9IkTJ/a0u7VH2Kta4ws7VrUWFRXFY28dHZ1Nmza5ubk5ODicPXs2KSlp1qxZ+Jr79u07fvx4dnb2QMw+7/ZS99GCBQvOnz9/+/btJV/GMnQsIN7ppeh2z1hh8c2bN2OFxd+8eYO/xeVH0K25c+dGRkbGxcUtXLgQWzI8CosjIxZ2v8KnWb18Ca9ewbZtoKgI334Ltrbw9ddAJvOwgUj3KACRGzagrMIIMixhWYU7fUtISKilpUVZWdnZ2XnlypXbt2+HL/OzeM7Ozu7p06c0Gm3p0qVYOcYjR45s2LChq94CrKumvr6+sbGxd19ue9fnMXD61OM6Xk3t4/v3ACAoJGRuYfHL5csEAuHBvXvYu9/Y2gIA/iMANDMYSY8fCwsLz7K05PIQX1lZAcDjhAR8SWVFRfZ/nxBw6ckTePMGSkuBvxOGDTbOJbC//vprOp1+7Nix+vr6jx8/enp6dtqJKiYmtm7dumfPnjU0NKSmpjo5OZFIJBqNNqAt57Kq9eTJk7OysvLz85OTk7Ozs83NzaFfi7CnpaXJycmZmZl1m9Wtj8XZOeOmgHinl4IbqLA4gvRIx19ebHRYcTGcPQvffgvS0jB/Ppx7pF4KgzSMeO7+804nBqScA4IgyDCAzcCSk5P78ccfnz59WlBQEBISoqury+t2/R97b4G8vDwWUnbbW+Dg4MBkMpOSktgX7tu3b8yYMdwkW2rX53H69OneNr9/9ClwBQC/jRszMzKaGYyKsrJTNBqLxZrx5duwz/bto8eO3bl1a8Lduw319Z8+flzv5lZaUrIjJESO67G+WwICpCmUXVu3Pn30qKGh4f27d17u7qK9+kY7axYYGMCoUSAkBKNGgYEBzJoF330Ha9fCjh1w9Cj89hskJMCrV0Cnw3+Hxw5b3ZbA3r179+rVq/fu3YuVe96yZYuiomJFRQWBQPD19cXLRktLSx86dGjr1q2KioozZ86kUCgPHjzAOjO5KS3dsdJ6amoqgUC4e/dua2srgUAICQlJTEwkEAiPHz9uaGjAUwJwrmqNncKRI0cmTJigp6e3ePFiGo2mp6cH/VSEHYMNMGZPYde/1ca5KUMP3BUQ7/RScGPIFRZHkAHV2AhVVfDpE2RmQloaPHoE9+7BtWtw8SKcPg3793PaFvue0NQEMTHgcnKKEhRt2oQyOSEIgvAGli1JXFzcyckpISGhpKSERqOZmZnxW08j9La3oI9dNb3u8xggBPbOZawWek4ltwNx3/7zz6WzZ5//+Wdhfj5ZWFhdU3Oxs/NiJyf8w66qrDwaGnr/zp0iOl1ERMTI2HjN+vUzZs4EgNPHju3dvh3f1bpNmyZMmuTm7IwvsXd0PBIWBgCfPn4MDgz888kTZkuLjp6ep4/PrydPJj1+DACLnZz2/fxzt+2MjSatcxErKoLycigvh5ISKCv793VZGZSW/vu6vBzYHz1IScGoUSAn9+9/srL//l9G5j//R8O9RghUhJ1PcFNYHEE61dgITU1QXQ0MBjQ0QH09MBhQU9Pj5V0RFQUyGSgUIJPh7dsuVxMQ+HfllaYf3O8uMGS9/v97BELNqgUMKrcPlbg3d/95WXHR8LVo4GvnyGlvpX6NAvbhdgQCRET8r707jWviavsAfGchISSQsAnuIlZUVFREXLCigkWForRqW8XWFWvd6o741D4iihvuC7611q5Ka0V9ELdWqoKoxa1uaLEqiCCKCYQ9ZN4PQ8cYFhHQBP1fH/xNzpw5c0+EMHfOmXMwVBjgtcQOFRaLxe++++6oUaN8fHzYHtfy2C6NqKiXMmLlRSdnevTo0cKFCw8ePJiRkWFlZTVw4EB7e/vw8HAicnV1/eCDD9hHXlkhISFLliwhouzs7LCwsOjo6NTUVIVC0blz5zlz5nh5eRFRYmKi3qxOeqOOk5OTJ0yYcP78eSsrq/nz50+ePLmWl/xCeDze7t27dXuVapW41hds4lqdyWIeP36a0z58SFlZT18+fkyPHlF2NunNOC2TlWWwFaa1uv8a33c38AKQuBoJJK5vlJwcKi2lJ0+otJRycqi4mPLyqLCQCgooL4+Ki8sqKJVUWkoqFZWUkFr9NOEsLia1+vkJp6kpSSQkl5NYTDIZyWQkFpNcThIJmZqSQkFiMUmlZG5OIlHF5WIx6T77/9FHtGsXlf+jIxJRcTG5uNDkyTRyJEljomjECL1kCYmrQSBxBXij3Lt37+TJk/7+/s99LumlJq5QtfKJa91PQlOvWVuTtfVz6pSUUHY2PX78zL9cWnv16tPywsKnR/F4ZGVFcjlZWpJCQQoFyeX6G3qFYIQ+/fTTTz/9VCqV1mw5O6ix+fPns6OjwWix+WR+PhUVUW4uaTSkVJJWS0olaTSUm0tFRZSfX1ZBraaSElKpytJOtgKbl7JpJ1uhCmz2KJORiQlZWJBAQJaWJBCQhQUpFGRmRhYWJBaTuTlJpSQWk0JRlqCWL69zUikJBE+H8PB4xOeTSESjRtGnn1LnznV/xroVe+nmJ5Fly8DELwpafuDEieQ7yrwCIrq+YoaVzOyxOj/i4KlDl29lqnLNJabdWzWdNcijfZOyx+mLNaVrDsXvT7qelq0yNRG6OTYJ7NXZq30rAZ+3JjY+/MAfRNTNscmBWaOJ6Pdrtz/cuIuILKWSGys/1zt70pLPFu/9/diVFBOhwMvZMWz4gNyCouCowwk370nFJt4d3lr8npfM9Gk/SdWBAQCwmjVrNnLkSENHAS8MiesLYx+RtavG38G8vKdJLJvWqlT05AkplaRUUno6XbtGSiWpVKRUUvmHq6tIcc3Myv6VSEihIKm07G7M3JxewoS4QEQ0atQo9oHMOlfFcxSLFi16qQt8G/DULyo8PJwdDAM1w2aGRMROys4mlmyqqbeLzRjZXWw/JxEplcQwZbvY/JPdpdU+7eesAp9PcjmZmJBMVpY9sqNq2Y8sBwfi80mhIKGwrPfSzKysApuXyuUkEJBCUZaXikRk5JP2y2RlQ2yEQtJoyMWFpkyhDz4w9rA5A11aZ25e8PHWXw5dvjnnx9g5g3uvH+17PT3Ld9VOIspUqQet3Fmk0awd5dvjraZp2ar5uw4PWrnz1+kju7ZsTETzdx8+cP76V+MD3Fs1zS0o2nwscfTWn/fOGNmzdfPPB/b6fGAvhxkruXP1a9cyc/OCAeFf33usKn/2L345Nt2n19pA35gLyVN27n+SV2AiEMz36+Nga7nn7NU5P8XKxKLF73uxBz43MAAAqNeeyXJMTYmIiotI9Ho9t1lUQBKJAc4rlZJUStWcQJsdycbmtGw2y6W4bPnDh3TrVtnLvLyy+8jy2FtDdjBbFfmtRPL0DpK9C2RvGdn7SyKytKzLtwKqUP0lT1+nUwNRWQaou8F2OXIbDEPswsnsgFi2r5LNEvV2sb2UXAKpm52yu6qD7bdkM0b2Y4HHK+uQZHfZ2pKpadmHDLeL6+dkD2E/VaRSEonKjlIo3rgHJWQyKikhiYRGj6agIMN0sTaasqxUq/8Lbjd5KbdtayG9Ej79ue1MGdCjZ+vmRNSlRaP0jcFENO3bA2nZqi1j/L3aOxKRU0PbyHFDXRduXBB1+Mj8sUR08sYdp4a2fdo6EJGpiXBRQP/Dl2uyFgARfdSzk0szeyIa5t5+w5HTv11NiZ45iu1BHd27M1vCJa5h+45XHRgAANRrzySu7CjZ7Gy+fcPXasWYJ0/4llaGDuJ5xGJq0ICqt8BtmcJCys8npbJscF1ODuXmUkEBqdWkUlF+ftnUl+zYvNu3Sa2m/HxSqyknp6zwueRy4vPLekXYO1F2eB7bJcLev7L3rNxdLHsI209C9LQTmNtg72V1N9hDAF4ZNtmjf1M73Q1uhCq3wT5LWeEGm0nqbnBZYvkNtg9Td6P62F8oNidkf+OIyhJC9heT/YqK28X+TrG72N9W7jspdpdudsrtgrri4kLbttGHH1awLs4rwyaZnBo/49qlRSO9kthLN/k8nneHVlxJAwtpm4a2l+5lpCtzGynM+zm3/ObE+Vk/HPyop0un5o0EfF7ClzWcGqBTc3tu214hS36Q1anZ0+XBGyrMr97PrH5gNYsBAACMxDOJK7tYUfI1wWuWuCZfF1R74Y/6xNSUTE3JqhY5OXv/zd5Ys30+7KBBdvgf/dtvo1KRVlt2Z697iFpNDx+WdfKw4wa5XiD2kBfFZbDcBtdXw21wXcFcqsxi7845uqOm9e7L2bv/8iclKut2Lk/vXJWFXR6XwBuVyrrr9XDZXXncT0jV9ctnaNU5kEsLifTHoOr+XOl2JHIjWss3qBtDFVdUBfbLGt0N7keI2+B+/NgEkujpcNbyG+w3Prob3A9e+Y03sLvyNfD++4aOoO6YiZ75CCvWlOYUFBFRq5mry1f+52F2I4V5+Aifrg5Ndidefm/dj0TUvVXT0R6dB3VyqsHZzU2fDgDj83gCPk+iE4+Az9P+26tcncBqEAAAABgP/R7Xt1rT6ZPCPv2rnBOjvkk8Kfx4tKGDMErsYOaXOiqYyzS4ZInbePLv9NXsBpf0lt/gsh3dtKekhG7ffnoirstLt00WN/yS9dxJX+ClKp/ncwkhS/ebBb2vDHS/CJDLqZFOV5DujzHb08jS/TKCO5yrwG2wPZC6G3pRAQARiYQCucQ0r6j47vq5wkq+sePxaJh7+2Hu7UtKtQk3724+ljhm257/vtd/Un93tgKfzyvWPPMdkqqgtkvZVicwAACo1/Rn8vHzpT17RfMWFbw23/FfuiBMvcf38zN0HG8qrqvTOB+a5XJjFveooZ7KyklnzpvyKuxdNAZ6vdOV4foDK/Tc/JMq78EGgPprcGenHxMunU1J6/lWM65ww5HTX/+RdC50spDPf2vW6oNzPnnL3tpEwO/T1sG9VdMWM1YcvZLCJa52FrIM5dPPzYc5efezVTLT2s6u8dzAatk+AIBhqdXqzp07Ozk5VX/p19eMfuI6dixFRPDjjpn09X5N+qS+2y52bk/duhk6DjBKPJ6RZtQAAMYpxN8z4da9Gd/9b9mId9xaNtFqtfvP31h98NS6QF8uOZz7U2zY8AGt7KxzCgq/OXGeYai3U3OuBc92LbfH/bk97s8PenTMyslbuj/OxlxaWKKp5IR1GRgAQP3FMIxWq9U++zCeTCbr1KnTqVOnDBXVq6SfuDo7k58fhX8p6d235DVYWOXaX4K9u0XffGPoOAAAAOqJpH/uD1q5k91uNn0FEWVuXsDttTGXHp77yZpDCcG7D6c/ybGQmHZoavftpPffbuPAVoj+PPCbk0kTt0enZavEJkLHBlYRIwd91LMT18J8vz6FJZp1hxMW7/3dpVnDxe973cmKvXQvw27y0qkDegx0aa179hk+vQa6tH5n+Q62xG7y0hD/vu6tmry7+juuZPbg3nMG935uYAAA9Zq5uXlKSoqhozAkXvn1MFJSqH17Cv5v/scTavvMicF94GfO0wrj4zG7CQAAGJmoKBox4pmp0ng81bihRa6v43SCxk2cdF2+fa/e/wXt3k3DX3geZgB4nQwfPpyIoqKiDB1IpV7jHlcej7d79+7hOp/DFQyecXSkGTMoYqkk5ZbgFcZW93ZEis+eFm7YgKwVAAAAAAAMKSsra9q0aS1atBCJRLa2tgEBARcvXmR3eXh48P41atQoIvLy8uJKlEpldHQ097KwsJCIVq1axePx8vLy4uPj2XLhazBctkoVP/WxaBG1a8cbM1yW/ai+5nwnfjcJ+49ZWBi5uho6FAAAAAAAeIM9ePDAzc0tKipq8+bN2dnZcXFx2dnZPXr0OH36NBGdOnXq4sWLUqnUxcUlMjKSiGJiYtzd3X/66SeGYRQKxZAhQxiG8ff35xqcPXs2wzBSqbRXr14MwzAMo9E8nSygX79+1tbWiYmJr/5KX56KE1dTU4qOJh6PHzRaps6tf7nrpfPCz8ZIR42i+fMNHQoAAAAAALzZgoOD7969GxERMWjQIJlM5uzsvGvXLoZhpk6dylZwcXHZsWPHpUuXRo8ezTBMUFBQ//79P/jgg5qdTqvVstls3V2B4VU6z16DBhTzP0q7K3zPxzztXn2aju/gftEH75p79OZFRho6FAAAAAAAeH1duXKFp2PKlCkVVouOjubz+b6+vlyJvb29s7NzUlJSWloaWzJs2LCQkJBff/3Vw8Pj8ePHoaGhNY6K69GtcQtGqKqM1NmZzpwhU7FgiLfF8aMmryymGisq4kUsk3w2Rjp+HB3YTyKRoQMCAAAAAIDXV/v27RkdGzduLF+nqKhIpVJptVq5XK6b5Z4/f56Ibt26xdUMDQ11d3dPSEgYNmwYH0t5Pes5j/A2bUqnTtLEibwxI2T93ylZuCTfwVFb9SGGcvh/Jku/MHv8iL95M02aZOhoAAAAoC7sS7q27nDC35nZRSUaIvpj4YQ2jWwNHRQAwAsQi8UKhUKtVhcUFFQ9hVJcXJxKperQocPkyZNdXFxcXFyqbpn3Jk1C+/w8XiajH3+k48cpM91kQE/55E+kR2NNCgqM5T16kM7/brvY19Ni0sey3h785GRkrQAAANUycMU3ozYbyzIPeUXF3Rdt0YvnbEpa0NfRnm1bXl8x48x/P22kMDdUeAAAtREQEKDRaOLj43ULly9f3qxZM25SpX/++WfcuHF79uzZv3+/RCLx9/fPysqqulkzM7Pi4mJ228nJadu2bS8jeCNR3UmTPT3pwnnatYsiI0VBgSKBgBzf0to11MpkhumALdXycpS8f24LHtznSaX03nu0Yzt17WqQWAAAAOAFOMxY2b6p3YFZo3ULGYa0DKN9diqR/eevMwxN6OsmFYuktqILS6e+2kgBAOrGsmXL/vjjj7Fjx27cuLFnz56lpaU///zz4sWLd+zYwfbBqtXqIUOGrF27tl27dkT0yy+/eHt7v//++8eOHTMxqfSZzS5dupw+fTo1NTUtLe327du9e/dmy/v163fp0qWYmJju3bu/mgt8BV5gtR+hkEaNolGjKDOT4uLo0iV+ZiY/N/flxVYVPp+aNyJ/X+rShTw8yNTUMGEAAABAnZCZis4unqxXmP4kh4ispBJDRAQAUGcaNGhw9uzZsLCwKVOmpKamKhSKzp0779u3z8vLi4imTJmyadMmIvL39//rr7/s7e09PT2J6MSJEyKRKDQ0tH379kOHDmWbkkgkI0eO/P7774lo7dq1EyZMaNu2rZWV1bp169q2bcvW0Wg0r9+swjVZptbOjkaMoBEj6jwYAAAAgKdKta/VXRcAvMmsrKxWr169evXq8rs2btyoN6tT+ZyzwizUycnpxIkT5csrLKzvapK4AgAAwJsm9tLNTyJ/Ybf/DP0sNPr349du8/l8N4fGS4Z5t7C15Go+yStYExt/6PLN9Cc5ZiKRq0OjKQN69GrdnIg2Hzvz319/I6KzKWl2k5cSkYDPS98YrNv4vXVzxSZC3ZJm01cQUSs7678zH3Nnme/X5/OBvTRabeMp4WyJb+c22ycEvOz3AQAADAKTLAMAAMDzDXRpnbl5gU/H1kS08OejE/t2u7Rs2v+NG3Iy+U7Q19FctYc5eQPCd/z659WwYQOur/w8dt4nEpHJe+t++CH+IhFN9nLP3LzATGTSzbFJ5uYFmZsXpG8M1mu8/OnurZubuXlB/KKgzM0L+rZryefxzvz3088H9iIiIZ+fuXlB15aNt4zxR9YKAPAaQ48rAADAm6LRlGXlB9+yPZ8sWwvplfDpz21nVK9OXVs2JqK32zh4t2914MKNbHW+lcyMiMKij997rIwcO8S7QysiMjcVbx07xO0/mxZEHRnQ4S1bC2ktL2FSf/fj125v/e1s+AfvsCVnU9LuZ+f4dWlby5YBAMCYIXEFAAAwDgIBj3m5c/Wz3ZucgSu+sZaZfT95+Iu206l5Q267kaUFEWWo1GzievBSMhF5tW/FVRAJBb3btPj5zJXj128Pd+9Q4+BZnm0d2jZqsCvx8jy/ty2lEiLadDRxnGdXE0HNB5HxGC0JBLUMDAAAXioMFQYAADAOFua8giJDB1EtFhIxty0SCoiIXcamWFOaU1AkNhHKTEU/WC+TAAAUVklEQVS69W3NpUT0MCevTs4+sZ9bQXHJjj+SiCjlYfapm3cCPTrXpkFefhFZYIVYAACjhsQVAADAKDAtHASZ2YaOolZEQoGFRFxUolEXFuuWZ+XmEVGDf8cJ83i82pzl/W7tbS2k2/9IKtaUbjl2ZkT3jgqzWi2LJ3iYzbR0rE0LAADwsiFxBQAAMAo8NzfRvQxDR1Fbg1yciOjYlb+5kmJN6ckbd0xNhH3btmRLJCKTYk0pu93zy63fnbrwQqcQCQVj3nZ9lJu35diZPWevTOjrVsuYRfcyeK6utWwEAOCFdO/e3dfX19BR1CdIXAEAAIzDO+8Ib6fx62g8raGEDOnbzFqx8JejR//6W11YnPIwe9LX0Zk56rDhA7iZmTo2tbv9MDv9Sc6ft+/ffaTs3qrpi55lzNtdTE2Eyw7Evd3GwUFnJZ4a4OfkCVNSycenNo0AAMDLhsmZAAAADIEdLsswxI2bHTiQzM1NT1/Kf6enAeOqTNI/9wet3MluN5u+YoZPr+B3+3AzEvdfut27favvJw9vYCE9Mn9MRGz8gqgjD5Q5EpGJq0PjX6Z95OHUgmsqdJj3rB8O9vpvpEIqWTLc+y17G71VW9/r1t6vcxu9dVwPzvnY1aExW2IlM3u/W/vv4y9O8upWy+syPX2J5PJnEleGISKq3XhmAACoW0hcAQAADEEmIyLKzyfpvyvESCQ0aZJ0y6aC3l2Y2j20WU2xcz+pfmVXh8aZmxfoFZYvISJLqST0fa/Q970qa6qVnfW+mYG6JeyqrdVpnNO1ZZO/UjN6tGr2nLirxMsvlB7/kz79jCSSp6W5uUREFha1aRkAAOoWhgoDAAAYQsOGRESpqc8UhoTwJGbSg6cMElH9svPk+Un93WvZiCzmJE9kSsHPrBJE9+8TEdnb17JxAIC6Eh0dzftXcnLy8OHDra2t2ZePHj0ioqysrGnTprVo0UIkEtna2gYEBFy8eJE7vKio6IsvvmjTpo2ZmZmVlZWfn9/+/ftLS0uJaMmSJWw7Hh4ebOVDhw6xJTY2NuXPfvfu3REjRpibm1tbWwcGBj558uTOnTt+fn7m5uYNGzacMGFCLvvd37+qDuyFIHEFAAAwhLZtycSEzp9/ptDcnMKWmv2RJEyt97M0vQw/xF/8JPKXvKLinSfPq/IL33VtW5vWhKkZkhPnKTyc5PJndpw/TyYm1KZNrWIFAKg7Q4YMYRjG39+fiIKCgiZPnpyampqYmCgQCIjowYMHbm5uUVFRmzdvzs7OjouLy87O7tGjx+nTp9nDp0yZsn79+g0bNjx+/Pj69ett2rTx9/c/efIkES1cuJBhGCk39ofIx8eHYRhXnSnrdM8+c+bMuXPnZmRkrF279vvvvx85cuSMGTNCQ0MfPHjw5ZdffvXVV4sWLeIOfG5gLwSJKwAAgCGIxdSzJx06pF8+Zgx59lFs+5WvUhsiLGMXe+lm61kR35w4HzluiJBf89sYvkqtiPyV+vShMWP09x06RD17klhc0XEAADUkFAp5Os6cORMTE6NbYl+9gR7z5s3z9PQ0MzNzd3fXaDQ2NjbBwcF3796NiIgYNGiQTCZzdnbetWsXwzBTp05lD/ntt9+cnZ29vb0lEomdnd3KlStbt25ds6sYN26cq6urVCoNDAx0dnaOjY2dOXNmp06dZDJZUFCQg4PDwYMHucrPDeyFIHEFAAAwkKFDKTqanh1VRXw+/bKHb22riNzDKy4xUGRGamSvTpmbF9zfOP94yPiOTWs+lJdXXKKI3MO3saU9e0gv+83NpX37KCCgtrECQP0nEAjY8bR1QqPRMDrc3d0HDx6sW5KRUa2xNt266U9KFx0dzefzdRfXsbe3d3Z2TkpKSktLIyIfH5+EhISJEycmJiayV5ScnOzp6VmDq+jatSu33ahRI72Sxo0bp6enVz+wymg0GiISCp+ZjwmJKwAAgIGMHk2lpbR1q365QkEHY4W5hZZrf0S/a53jq9SWa38U5hbSwVhSKPR3b91KpaUUGFjRoQDwZpHL5SqVytBR6NMd1ktERUVFKpVKq9XK5XLd/tvz588T0a1bt4ho06ZN33777e3bt/v3729hYeHj47N3796and1CZ+I6Pp8vEAjMzMy4EoFAoNVqqx9YZdi3XfHsRzQSVwAAAAOxtKQ5cyg0lB480N/l6EhnzghFUqtV3+J51zokTM2wWvmtUGRGZ86Qo6P+7sxMCgujOXPIslZrwwLA68HBwSE5OdnQUTyHWCxWKBRCobCkpIQpp2/fvkTE4/ECAwOPHTumVCqjo6MZhgkICIiIiOAa4fP5xcXFus0qlcpXEFhl2Le9ZcuWuoVIXAEAAAxn7lyytKSQkAp2OTrSmTP8Tq5WK3aa/3yUl1/4yoN7rfDyC81/Pmq1Yie/syudOVtB1kpEwcEkl9Pcua88OgAwRq6urmlpaVUPajUGAQEBGo0mPj5et3D58uXNmjVjx9wqFIobN24QkYmJibe3NztLcExMDFe5YcOG99kJ1YmIKCMj4969e68gsMqcOXPG0tKyefPmuoVIXAEAAAzHzIzWrKFvvqGdOyvYq1DQkSMUGSn56x+bxdvMDifwc/JeeYj1Hj8nz+xwgs3ibZK//qHISDpypIIRwkS0cyd98w2tWUM6w94A4E3m4eEhlUoPHDhg6ECeY9myZY6OjmPHjo2NjVWpVNnZ2ZGRkYsXL161ahX3mOikSZMuX75cVFT08OHDFStWMAzTr18/roUBAwakp6dv3LhRrVanpKRMnz69QYMGryawCu3fv9/Hx4fH4+kW8hiGqX1MAAAAUHMLFtCqVXT4MFU2dEqlomXLKDKSVCpNyybFzRuWNrBizEwZPq/i+m88npbh5RcIHj4R3X0gvJ1GcjkFBZV1qFbo1Cny8qJZsygs7NVGCgBGbfTo0VevXk1KSqrzlrt3725jY/O///2vOpUTExN79OihW6KXxGVnZ4eFhUVHR6empioUis6dO8+ZM8fLy4vde+nSpS1btpw4ceLu3bumpqatW7ceN27cuHHjuMxQpVLNnj07JiZGqVS6urquWbNm0qRJ7FXPmzdvyJAhumcPCQkZMmSIm5sbV7Js2TIPD4/evXtzJYsWLfryyy+fG1iFbt265eTktG/fPj8/P91yJK4AAACGptXS8OF0/DhFR5POH359BQV06BAdPsycPcu78w/l5FCp9hVGWa/w+WRhwTg48NzcyMeHBg4kU9NKK588SUOGUN++FBWlP8kwALzZzp075+7uvmfPnqFDhxo6ljfFyJEjz549e+PGDXaVWg4SVwAAACNQUECBgXTgAG3bRh9/bOho3iQ7d9LEieTnR999RxKJoaMBAKMTGBiYkJBw9epV0yq+/4I6kpCQ4OHhUb67lfCMKwAAgFGQSOjnn2nWLBozhsaOpcxMQwf0BsjMpLFjacwYmjWLfv4ZWSsAVGj58uUPHz4Mw3MEL19hYeFnn302YMCA8lkrEQnYwccAAABgYDwe9e9PHTvSli20ciUJhdSxI4nFhg7rdZSbS+vX07Bh9OAB7dhBU6YQD08LA0DFzM3NraysgoODnZ2d27VrZ+hwXlsMw3z88cdJSUl79+61srIqXwFDhQEAAIxMfj6tWEErV5JAQP7+5ONDXbpQkyZkbm7oyOqznBxKS6MLF+jQIdq3j0pLac4cmjsXcwgDQHVMmzZt+/btcXFxupMSQR368ssvly5dGhsb279//worIHEFAAAwSk+e0LffUnQ0nTpFVa53By9AKCQPDxo6lAIDydLS0NEAQL1RWlr67rvvnjp1ateuXQMHDjR0OK+V0tLSuXPnrlmzJjIycsKECZVVQ+IKAABg3IqK6No1ysyk3FxDh1KfmZuTnR21a4fR1wBQM8XFxUFBQd99911ERMTUqVN5eMSgLuTk5IwaNero0aNff/31hx9+WEVNJK4AAAAAAADVEh4eHhIS4uHhsW7duk6dOhk6nHqMYZhvv/02ODhYq9Xu3btXb6Ha8jCrMAAAAAAAQLXMnz//7NmzGo2ma9euY8aM+fPPPw0dUf1TXFwcFRXVvXv3cePGDR069Nq1a8/NWgk9rgAAAAAAAC+EYZgffvghPDz86tWrLVq06Nu3b4cOHWxsbLDWaxVycnLS0tIuXLjw+++/5+fn+/r6Ll68uGPHjtU8HIkrAAAAAABATZw9e/bAgQOJiYlXr1598uRJYWGhoSMyXubm5nZ2di4uLv369fP392/cuPELHY7EFQAAAAAAAIwannEFAAAAAAAAo4bEFQAAAAAAAIwaElcAAAAAAAAwakhcAQAAAAAAwKghcQUAAAAAAACjhsQVAAAMTK1W83ScPn26sppz5szhqi1ZsuRVBmkoMpmMV6Wvvvqqbs8YFRXF4/HEYnHdNgsAAFAbSFwBAMDAZDIZwzAXLlxgX4aGhlZY7fHjx1u3biWikSNHMgyzcOHCVxdiTanV6rfeesvX17c2LbDvjL+/P1NOnz596i7YMra2tty/AAAARgKJKwAAGAuJRNK8efPY2Ng///yz/N41a9Y0bdq0Bs3KZDIPD4/ql9chhmG0Wq1Wq32pZ6lbSFwBAMAIIXEFAABjwefz58+fT0TlhwErlcotW7bMmzfPEHHVnLm5eUpKysGDB19S+3FxcePHj6/bNpG4AgCAEULiCgAARmTMmDGNGzfev3//5cuXdcvXr18/aNAgR0dHQwVmbKZMmTJjxoyX0bKNjQ2Px0PiCgAARgWJKwAAGBGxWDxnzhyGYcLCwrhCtVq9YcOGBQsWlK+v0Wh2797t7e1tb28vkUg6dOiwbt06bmjuqlWreDxeXl5efHw8O5WRUCisopyVlZU1bdq0Fi1aiEQiW1vbgICAixcvsruio6O5WZGSk5OHDx9ubW3Nvnz06JFebLqVCwsL2cKioqIvvviiTZs2ZmZmVlZWfn5++/fvLy0trc2btmTJEvYs3MjnQ4cOsSU2Njblg7lz586IESMUCoW1tbWvr29KSopuawKBwNLSEokrAAAYl/IzPQAAALx6Fy5ckEqlDMPk5+fb2dnx+fxr166xu8LDw4cPH84wzMmTJ+nfyZlYBw4cIKKlS5dmZ2dnZWWtX7+ez+fPnj1bt2WpVNqrV6/yZ6ywPD09vXnz5nZ2djExMbm5uVeuXOnTp4+pqWlCQgJXx9/fn4j69Olz/PjxvLy8xMREgUCQlZVV4XWxlQsKCtiX48ePl8vlR44cyc/Pz8jImD17NhEdP3686nemwr/g06dPr/pyXF1dra2tywfj7++fkJCgVquPHj0qkUjc3Nz0zujk5LRkyZIqQgIAAHjF0OMKAADGRSKRzJw5U6vVLl26lIjy8/PXrFkTEhJSWX1PT8/g4GBLS0sbG5upU6d+9NFH69aty8nJqdnZg4OD7969GxERMWjQIJlM5uzsvGvXLoZhpk6dqldz3rx5np6eZmZm7u7uGo2G69us2m+//ebs7Ozt7S2RSOzs7FauXNm6devqHKg3q/Bnn332wtf2r/Hjx/fo0UMqlXp5eQ0ePPjcuXN63cU2NjbW1tY1bh8AAKDOIXEFAACjM3nyZGtr659++unvv/+OjIzs3r17x44dK6zp6+t7/Phx3RIXF5eSkpKrV6/W7NTR0dF8Pl93ARt7e3tnZ+ekpKS0tDTdmt26datB+z4+PgkJCRMnTkxMTGRHCCcnJ3t6etYs2ppxc3PjttmJmtPT03UrCIVC3bHTAAAABoc/SwAAYHRkMtmMGTP+85//LFq0KC4ubt++fZXVVKlUq1ev3rt3b1pamlKp5Mrz8/NrcN6ioiKVSkVEcrm8/N5bt241adKEeymVSmtwik2bNvXo0WPnzp39+/cnot69ewcFBQ0dOvRF29m4cWMNzs7SvTqRSERE9WvBHgAAeAOhxxUAAIzR1KlT5XL5jz/+6OLi0rVr18qq+fn5hYaGTpgw4ebNm1qtlmGYNWvWEBHDMFwdHo9X4bHly8VisUKhEAqFJSUl5Z+u6du3b+2vi8fjBQYGHjt2TKlURkdHMwwTEBAQERFR+5b5fH5xcbFuiW4m/0Jexio7AAAAtYHEFQAAjJFcLp85c6ZcLl+4cGFldUpLS+Pj4+3t7adNm2Zra8smogUFBXrVzMzMuIzOyclp27ZtVZQHBARoNJr4+HjdFpYvX96sWTONRlP761IoFDdu3CAiExMTb29vdrLfmJiY2rfcsGHD+/fvcy8zMjLu3btX+2YBAACMARJXAAAwUl988YVSqezZs2dlFQQCgaenZ0ZGxsqVKx89elRQUHD8+PGtW7fqVevSpcvNmzdTU1NPnz59+/bt3r17V1G+bNkyR0fHsWPHxsbGqlSq7OzsyMjIxYsXr1q1qq4e+5w0adLly5eLiooePny4YsUKhmH69etX+2YHDBiQnp6+ceNGtVqdkpIyffr0Bg0a1KCdpKQkGxsbDw8PjB8GAAAj8gpmLgYAAKia7vOi77zzToV19P5+bdiwgWGYrKysoKCgpk2bmpiY2NnZffLJJ/Pnz2cruLq6sgfeuHGjd+/eUqm0adOmmzZt4hqsrPzx48czZ85s2bKliYmJra3tgAEDjh49yu46ffp09f+M7t27V7cmu4rPxYsXg4KC2rZty67j2r179//7v/9jBzk/950hIjs7u8pqKpXK8ePHN2zYUCKReHh4nDt3ztXVlT1q3rx5epGHhITovaWDBw9m2zl37hwbWGlpaRVXBwAA8CrxmHK3AgAAAAAAAADGA0OFAQAAAAAAwKghcQUAAAAAAACjhsQVAAAAAAAAjBoSVwAAAAAAADBqSFwBAAAAAADAqCFxBQAAAAAAAKOGxBUAAAAAAACMGhJXAAAAAAAAMGpIXAEAAAAAAMCoIXEFAAAAAAAAo4bEFQAAAAAAAIwaElcAAAAAAAAwakhcAQAAAAAAwKghcQUAAAAAAACj9v/H5NwuMWtoxgAAAABJRU5ErkJggg==\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": "iVBORw0KGgoAAAANSUhEUgAAA9AAAACYCAIAAACDL5YjAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdeTxU6xsA8OfMMIwZO1lapUQSrSiVSFchcttLt038uoW0iLqlaC+lRalu2+22uC0S7UqLaE8lUiolWSI7w5jz+2NucyfEGMMMnu+nT5/xnnfe85wzzvHMOe95X4IkSUAIIYQQQgg1DYq4A0AIIYQQQqg1w4QbIYQQQgihJoQJN0IIIYQQQk1IStwBIIQQQgghscnLy0tMTPz27RuLxRJ3LJJLXl5eQ0OjZ8+eMjIyQrwdE26EEEIIoTYnMTHx4MGDkZGRKSkp4o6lxZCSkho8ePDYsWOnT5+urKws+BsJHKUEIYQQQqjtePv27aJFiyIiIrp16+bs7Dx8+HAjIyM1NTXhrt22EUVFRZ8/f37y5Mnly5fDw8OrqqqWLFmydOlSOTk5Qd6OCTdCCCGEUJtQXl6+evXqbdu2de/efdOmTba2tgRBiDuolqeoqGjv3r2BgYFKSkrbt28fO3ZsvW/BhBshhBBCqPXLzs52cnJKSkoKCAhwd3eXksJ+xY2SlZXl6+t7+PDhZcuWrV27tu6vLphwI4SaTFYWxMRAQgJkZUFRkbijacnk5UFDA4yNwdISNDTEHQ1CqOVJTEy0t7eXkpK6cOGCvr6+uMNpPY4cOTJ37lwHB4e//vqLTqf/rBom3AghUWOz4eRJ2LsX4uKASgV9fWjfHuTlxR1WS1ZUBJ8/Q3IyVFWBuTm4u8OkSYBXpxBCgvn06ZOpqamurm54eLiqqqq4w2lt7ty54+TkNHz48LCwMAql9hG3MeFGCIlUTAx4eEByMjg5gYsLWFuDYA+UoPqVlkJ0NPz1F4SHg74+7NgBlpbijgkhJOlKS0stLS2Li4vv3bunpKQk7nBap7t3744YMWLRokVr166ttQJOfIMQEpHiYpgyBYYPh86dITERwsLAwQGzbVGSkwMHBwgLg8RE6NwZhg+HKVOguFjcYSGEJNqcOXPS0tIuXrwoXLa9ZcsWgiAIgujQoYPIY2s1LCwsQkND169ff/bs2Vor4BVuhJAofPoEY8ZARgYcOgSjR4s7mrbh4kWYORO0tSEiAjp2FHc0CCFJFBMTM3z48KioqNGNOzObmJh8/fo1PT1dVIG1SrNmzYqOjk5KSqo5ViAm3AihRktMBBsbUFWFCxegS5e6apIkvH8P79/Dt2+AJ5+foVBASQl0dEBHB+oesevDB3BwgNxcuHYNDA2bKz6EUMtQVVXVt2/fzp07R0RENLIpTLgFkZ2draen5+Xl5e/vX20RJtwIocbJzgZTU+jQAaKiQEGh9jpVVRAVBcePw+XLUFDQvPG1ZIqKYGsLU6fC6NFApdZep7AQ7OwgPR3u34d27Zo3PoSQRDt27NisWbMSExO7d+/eyKYw4RbQ5s2b/f3909PTq81DiQk3QqgRysvBygoyM+H+fVBXr71ORAQs9IL3Hyp7dGH10q3UaV+lrsxh0Ou5dtuWkSSlpIya8036/WeZl6nSrz+AThfYth3GjKm9fl4emJmBoiLcuoWd5hFCPBYWFtra2mFhYY1vChNuARUVFbVv3z4wMNDDw4O/HB+aRAg1wurVkJQEFy/Wnm2/fQsjbcDJiaXGyPV3/+YxudRqYKVOew5TDrPtuhAEhylXqdO+1GrgN4/Juf7u5WoMcHICGxt4+7aW+ioqEBEBb99CQECzx4oQklCZmZlxcXEuLi511OF/IPLhw4fW1tby8vJycnLDhw+PjY2t441sNvvUqVM2Njaampp0Ot3IyCg4OJjD4fAqsFislStX6uvry8nJqaioODg4REREVFVVAUB4eDjxXVpa2sSJE+Xl5VVVVV1cXL59+/bhwwcHBwd5eXktLS1XV9civjkc6l2pJJCXl3dycqr56CQm3AghYaWmwrZtEBgItc6hEB0N/fuzXyd+855WMGNMlbpyLXWQAKrUlQtnjPnmPY2dkgj9+0N0dC2V9PUhIACCgiAlpdkDRAhJopiYGCqVam1tXUedxYsXkyRpbGycn5/v6ekZGBiYmZl5+/btvLw8KyurW7du/eyNly9fnjRpkpWVVVJS0qdPn+bOnevt7e3j48OrMH/+/B07duzcuTM3NzcpKUlfX9/R0fHOnTsA4OTkRJKko6MjAHh7ey9dujQzM3P79u3Hjh2bOnWql5dXQEDAly9f/P39Dxw4sGrVKsFXKiF++eWXe/fusVgs/kLsUoIQEtaYMfD+PTx9WssMLPv3w7x5rD76hdNGk9I4P4toEJVshWMXZZ4mQ0gIuLpWX8xmQ58+oKMDjX46CiHUCvj5+V24cOHFixf11jQxMUlISHj69KmJiQm35MWLF7179zY2Nn727BmvDn+XksjIyK1bt968eZPXiIuLy6lTp75+/aqgoAAAXbt21dLS4r9M3qNHj9DQUMvvswc4OTmdP3+ef/iUXr16JSYm3rp1a+jQodySrl270mi05ORkAVcqIZKSknr27Pns2TNjY2NeIV7hRggJJTERLlyAjRtrybZPnAA3t5JfzAtmjMFsW4RIaamCGWNKfjEHNzc4caL6Yikp2LgRLlyAxERxRIcQkixfvnzpKPCAoQwGg5dtA4CRkZG2tnZCQsKXL19qrW9vb8+f+AKAsbFxZWVl4vfzj62t7b179+bOnRsfH8/tSfL69WvLGnN19e/fn/daW1u7Wkn79u0zMjIEX6mE4A5YXm3XYcKNEBLKwYPQrRuMGlW9/NEjmD2r1Hpgid0QwH7aIkdAid2QUquBMHMmxMVVXzpqFOjqwqFD4ogMISRZSktLGQyGgJVrzonTrl07AMjOzq61fkFBwcqVK42MjJSVlbm9sZcsWcJdKbfC7t27jx49+u7dO2trawUFBVtb23PnztVsh//KNIVCoVKp/CNYU6lU/i7a9a5UQjCZTADg730OmHAjhIQUGQm//lr92cfcXBg9uqJ7p+KxVmIKq00odraq6NEZHB0hN/eHBQQBv/4KFy6IKS6EkAQhSZIQ+PH03Nzcan2Mual2u58MNurg4BAQEODq6pqSksLhcEiS3LZtG3el3AoEQbi4uFy/fj0/Pz88PJwkSWdn56CgIOG3R4CVSgjubq8WFSbcCKGGy82FlBSocXMQVq7ksCsKZjjgICRNiyAKZjhw2BWw8o/qi4YPh5QUyMsTR1gIoZaqvLz84cOHvB9fvHiRkZFhbGyspaVVs3JVVVVsbKympqaHh4e6ujo3vywrK+Ovo6SkxO17LS0tbWNjwx2ZJCoqSugIBVmpJMOEGyHUcElJAAC9ev1QmJgIoaHFY4aSsjJiCapNIWVlih2GQmgoJCT8sID7oXx/xgghhAShqKjo5+cXFxdXUlLy6NGjadOm0Wi04ODgWitTqVRLS8vMzMzNmzd//fq1rKzs5s2be/furVbN3d39+fPnLBYrOzt706ZNJElaWQl/81PAlUosTLgRQg3H7clQbext32XszlrlA43EElEbVG5qxO6sDX+s+KGU+6F8/SqWkBBCLRSTydy5c+fq1au1tLSGDh2qrKx848aNYcOGwfexuhMSEj5//kwQxIoVKwDg1KlTbm5uO3fu1NbW1tHROXr06JQpUwDAxsaG+9TjrVu39PX1J02apKKiYmBgcPny5f379/v5+QFAfHw8QRDnz58HADqdvmLFikePHhEEceXKlaqqKoIgNmzYcPfuXYIgbt26VVJSQhAEd6b0elcqyXBYQIRQw4WFwcSJwH/2SE+HLp0LZjqy+hqIL6w2R+ZxkuLh8/AhDTp0+K+UIODUKZgwQXxxIYTEb8KECQAgyDSTOIukyBEEcerUqQl852EcsQshJArnz5MyMhW99equ9SYzNzD8ZmxKWmVVlb62+uLRQ0JvPLjz+gMATBlkvG2aHZvDiXqafCw2ISkju7CMpaOuPG2wyWzL/pTvncIr2FXbLsdGPE5KzyuQlZYaoNvBZXCfEb26USltsdd4hbEeSaMREREwb564Y0EIIfRTmHAjhEThxo2K7p1IKWodVd7nfLPbfERORvpPV+f+Xdun5xWs+Of6q8/ZNCnqpx3/ThV2M/Hd3D/D/Rwt988Zy+Fwzj569cc/1zK+Fa5y/neytGWnrlx4knRgjrNpt45FZayQ6/HT9/5zzmvqIL3OTb6NkoeUolbodZaJjsaEGyGEJBn24UYIiQD57Bm7Q+2jR/GsOx9TUFYeON5mmIEOQ4bWQ0t97yzH0orKatUG6XX2/GWQkpysClNujmV/5wGG+28+LCr/d47cO8kfemipDzPQkZWWUldgrHK21m2n0iSb1EKwO7Qjqz03iRBCgqm1fzZqCphwI4REgMj8UqVcz8y6N16lAsDwnl15JapMue4aqvx1bIy6nfOayl9i2EGjsorzOuPfpwCtDLs+fJe+6O+Lj99/ruKQAHDP371tXt7m4igrEJmZ4o4CIdQiLV68mOQTGBgo7ohaLexSghAShbJykJGuY3kFu6q4vEJGWoohQ+MvV5ST5f+xsIy1J/r+xWevv3wrKigr/6/5yn8vhG+YaNtfp8Op+Oe/Bh8HALNuHadb9Blt0kNkG9LSkDLSIGGzrCGEEKoGE26EkCiQJFnnTO40KSpTllZcXlHCquDPub8W/ZAsuuwJi3/7KXC8jfMAQxWGHEHAvhsP/jh9nW/2Mhhv2mu8aa/KKs69lLSQ6/Ez951Z/au1u7VpU2yW5COBABxsCiGEJBt2KUEINRNrQ10AuPHqHa8ku7AkNfu/ycmrOOSD1PR2CgzX4QNUmXLcgUnKKtn8jXRftPVNZi4ASFMpwwx0jriPJwi49jK1eTYBIYQQEgIm3AihZuI3xlKJQf/jn2u3kt6XsCqSM3I8j15op8DkVaBSiEF6nbMLS3Zfi88rLi2vZMempB2586RaO0tPXHr1ObuCXfW1qGTX1TiShCE92m4fboQQaimYTKaFhYW4oxAP7FKCEGomXdSVLy75LeDcjdn7z7I5nF4dNJY7WW6KvJNb/F+vkv2zndZfuHUg5tH6iBglBt26p+6vAwx3XIkbv+OEcSfNq8tmhS90OXzn8dw/w9PzCmSkpXTbqQRNHT1lkIkYtwshhBCqW4MT7vR0iIiAGzfgWQJkZ0FRUVNEVT8KBRSVoGtX6NcXfvkFRo0COl08kSCEBKfbTuWw2zj+kuyCYhXmf0evClNu8+RR1d613HE477Vhh3Y1KyCEEEKSrAEJ9/PnsHIlREYCnU4OGsoeM46tqU0y5cXzsA7JgfxvxId3lMcPpf78U0peAdzmgq8vKCqKJRyEUP2yC0uGrAl9udFLmvpvZ7ZPuQUfcr6NG9hLvIEhhBCqW05OTkBAQEREREZGhqKi4pAhQ1auXGliYgIA4eHhY8eO5VZ7//69j4/PlStXqFSqubl5cHCwrq4uAGzZsmXJkiUAEBsbSxAEAFCpVDab3aDGk5OT//jjj+jo6Ly8PO671NTUmntHCEughDsvD/74A0JDwcikaseB8pGjKqRp9b+r2XzNoYQdox3YI3vwELF+HcycCRTsmo6QRMovLV9y/OJS+6HKDHpyRo5v2FUmXcZ7dBvt0ocQQi3Cly9fzM3Ny8vLDx48OHTo0LS0tN9//93c3PzGjRvm5uZOTk4kSTo5OZ0/f97Ly8vHx+fgwYNxcXFjxoyZPHnygwcPAGDx4sWLFy9mMpkmJiZ3794VrnE3Nzd/f//Dhw+/ePFi8ODB3LdbWVklJCRERUWZmZmJYdcIrP7MNC4ODHrCmbPkph0l564W2jlKVrYNAGrqnHkLy288KLAfy3J3h19sIT9f3DEhhGpop8A47TmloIw1Juiv7ouDXPb+07WdypWlMzqrKYk7NIQQQj/l6+ublpYWFBQ0evRoJpNpaGh48uRJkiQXLFhQreacOXPMzc0ZDMaIESPs7OwePnz49etXUTXu4+NjaWkpJydnamrKZrO5l7c5HA531h4Rbm9TqOcK94kTMGsWWFhWbg8tEVfvEQEpKpGr1pf+OonlOpVpZk6JigRdXXHHhBD60ZAeXYb06CLuKBBCCAEAvHz50sjIiPfj77//vmvXrprVwsPDKRSKvb09r0RTU9PQ0PDx48fp6ekdOnTglQ8YMID3umPHjgCQkZFRd8cPwRsfOHBgzbfHxMTUuYmSoq6Ee/9+cHOD2f8r911dRqU2W0iN0su4Kvx6ketUprk5NS4Oc26EEEIIodr16tWr3mvDLBaroKAAABRre07uzZs3/Dkxfx0ajQYAHA5HVI0zGIy6Q5VkP+1SEh0Nv/8OnkvLVwS2mGybS0OTc/JCkVaHKjt7SexbsmXLFoIgCILg/x0Sok6LcOzYMeI7JvO/4ZbDwsIIgpCRkRFjbBJLuE//5MmT3HfJyv43U/qyZct4+1/CO7chJHI/O/9IDhEe7HW4f/++g4ODtra2goLCoEGDgoODuQ+cSZoW94ev7ZyrZWRklJSUpKSkKisryRqGDx9efxPfcR+XbKLGJVztCffbtzB+PIweU+G5tKyZAxIJOTly/9/FhYWcceOhzm9WYrB48WKSJI2NjRtap7i4uHv37vz3XFqKPXv2kCRZXFzMK1FXV+f9z9NyN1C0hPv0J02aRJKktbU1f+GGDRu45yxqy/rS3DglrAqzVXumhYSJO5BWookOzGY73qudfyTqPCPCg/1nYmNjLSwsOBxObGzsly9fPD09fXx8li5dKmCEzbm7BPnjKFHa1Lna2dmZzWbHxsbyF27cuLFTp068kUYEIScnV1FRwX3do0ePffv2ibBxCVd7wv37fNDuULVpV2mNryIthoYmZ//fxbdi4NAhcYciIiRJcjicum/NiEpTzwVVa8LdnBsoOAmZFksyd45kIkngkCTnx5ukOl6bHbYeFVdILVoT/e6J61da8g8l0UZ44MABNpu9fft2HR0dBoMxceLE2bNniyuYtqC17rH169fr6urOmjXr0qVLBQUFeXl5oaGha9as2bJli5RUAwaY7tu3b0pKyqdPn+Li4t69ezdkyJDGN25lZaWqqhofHy/85jWLWrbk/Hm4dhVOXSiVkZHopyTr1cu4avoclq+fzK+/glLLHwVBXl4+NTVV3FGIRq0Jd2vaQJHDnSM4piztwZp54o6i9Wii3z1x/UpL/qEk2gi53XMzMzO7d+/OLdm9e7e4gmkLWusea9eu3YMHD9auXTt//vxPnz4pKSn16dPn/PnzI0aMAID4+Hhzc3NuTTqdvnz58sDAQF7vkT59+tjZ2UVGRgLA9u3bXV1dDQwMVFRUgoODDQwMGto4fP+t5mGz2S1ylJKqKli0GMb8WjFwUGu4jO+5tOz8adqGDcSGDeIOBfFRU1MjCKJawo0QQki0nJ2djxw5smDBgrt370pmR3bUUqioqGzdunXr1q01F5mZmdXMd2vNgHv06HH79u3GN86v1gYlUPUuJVFR8C4VFi5rkV23a1JUImf/r3zffigT3QaxWKyVK1fq6+vLycmpqKg4ODhERERUVVUBAPcrHUEQvE4Ily9f5pbUOiZOcnKynZ2doqKinJzc8OHDq3Vg4hceHs57oqK8vLxaSVpa2sSJE+Xl5VVVVV1cXL59+/bhwwcHBwd5eXktLS1XV9eioiJeU2w2+9SpUzY2NpqamnQ63cjIKDg4mHf/i/sUSElJCXcuKIIg+G/o5OTkeHh4dOnShUajqaurOzs7P3v2TIh9SKVSlZWV+RPumhtY966uG39rHz58mDhxopKSkqqqqr29fbVrD7m5ud7e3rq6ujQaTVlZedSoUTdv3hRkV9QqPz+f4BMYGAgAbDabVzJu3Dio7yOoe3N4OwcAkpOTnZycFBUVGQzGkCFDqk0l0HLlFpcuD7vab8XuDgs2GCzdPnPfmZfpWdxFDluPasxbx/0373AEAIwLPs4rKSgrv5SQwvuRVckGgJDr9zXmrSutqHyQms4t156/Xpyb16L87HevjgNHkKOv1maVlJSIGigUSnp6OrdC488/IjzPtJSDXVdXV0FBISEhYcyYMfwNCkK0p2Vo+N4QZHV1/CrWoaV8fKg1qZ5wnzgB5kPYXbq2nu5HE6ZVFBbA5csia3D+/Pk7duzYuXNnbm5uUlKSvr6+o6PjnTt3AGDFihUkSfIPW2Nra0uSZL9+/Wq2U1xcPG/ePD8/v8+fP9++fTsvL8/KyurWrVu1rpQ705Kjo2OtJd7e3kuXLs3MzNy+ffuxY8emTp3q5eUVEBDw5csXf3//AwcOrFq1ivfGy5cvT5o0ycrKKikp6dOnT3PnzvX29vbx8eEu5T4FwmAwBg8ezL1Hw3tk4cuXLwMGDAgLCwsJCcnLy4uJicnLyzM3N4+LixNiN6qrq/Mn3DU3EOrc1XXjb83Ly8vLy+vz58+nTp26cePG5MmTedUyMzMHDBhw/Pjx4ODgr1+/3r9/X05Oztra+sCBA3Xvip9RUlIiSdLW1pZCobx9+3bFihUAICUlRZKkubn58ePHT58+DfV9BHVvDs/bt2/Nzc0fPXp0+vTprKyskJCQgICAVnArM6ugeOSGQ+efJG2cZPt6i3f4wqn5JWWjNx959O4zAFxYNP2G3xw5mrRhh3ZbpowCgOO/T+zbRTt0llNWiJ8iXXaUsV5WiJ9tbz1eg/NGmGaF+MnRpAfqdsgK8csK8cvY5ctb6rz97x5Ltj1+/7n5t7RFqPV3r+4DR5Cjr9ZmAaCoqIg3OsGaNWsAYO3atdwhIERy/hHheaZFHOw3b94cOHDgmjVrHB0db968OX78eN5JzN7evlpy2aS7i6uhe6Pe1dX9q1iHFvHxoVbmh4SbJOHyFRjxS4W4omkKauock35VIky4o6OjDQ0NbWxs6HS6hobG5s2b9fT06n9bDQUFBevWrRs8eDCTyezfv/+xY8cqKio8PT2FaGr27Nn9+vVjMBguLi6GhoaXLl3y9vY2MTFhMplubm46OjoXL17kr29paenr66usrKymprZgwYIpU6YEBwcXFhbWvRbB54IShJqamqqqat11RLKr65j1ytfX9/3799u3b7e3t1dQUNDT0zt+/LiWlpaHh0dWVpYQG8W1ePFiDocTFBTEK4mNjf38+fP48eN5JcJ9BPz8/Pzy8/ODg4NtbGyYTKaRkdGhQ4e+fPkidNgSYu35m+l5BWt+HTGily5DhtZDSz109liSJP3CrnArGHZoFzzdPjE9e/7hCJKExccvDtHv4tS/p3CrI0kSWkDfP8ki+IEjxJxzXGFhYatWrZoxY4avry9vpSI8//BrzHlGkg/2r1+/jh07dsiQIZ6enqdOnbKysoqMjHRxceFeoI2MjHz37h2dTmez2dzkUkCNPC03dG/UvbpGnsMl+eNDrc8PCfe7d5D/DfoOFOjeUAti0q/yyVORtWZra3vv3r25c+fGx8dzb2y9fv3a0tKyoe3IysqampryfjQyMtLW1k5ISBDiOOzfvz/vtba2drWS9u3bZ2Rk8H60t7evdsfN2Ni4srIyMTGx7rXUPRdUQ2OWkpKqt4eGSHZ1rbNecX88d+4cANjZ2fEqyMjIWFtbl5WVXblypUFr4Wdtbd2nT5/Dhw/n5uZySzZv3uzl5cXbXqE/An6XL18GgF9++YVXoq2tLdx3v+aRnJHD6+yhMW+d76na9/ClhBQKQdgYdeOVtFNg6GupJ3zMzMj/t2fUmL4GXraDo569dth6NK+kbJnDMKGjOrdw2ust3v27the6hTZI8AOnjqOvpvz8fG4n4/v37//2229Dhw4NDQ3lLRXt+YdfY84zknywHzp0qKCgYOrUqQAgIyNz/vz5gQMHnjx50t3dnVshJibGwsKioePQNWZ3CbE36l5dI8/hkvzxodbnh4T7/XsAgM46rS3h1tHlvHsnstZ279599OjRd+/eWVtbKygo2Nraco/5hlJVVSV+HHaxXbt2AJCdnd3QphQUFHivKRQKlUqVk5PjlVCpVP4+ZwUFBStXrjQyMlJWVubeT1yyZAkAlJaW1rEK7lxQHA5HUVGRv+vbkydPAODNmzcNjVkQItnVP5v1irtFsrKy8vLy/PU1NDQAIDMzszGRL1q0qLS0NCQkBABSUlJu3749Z84c3lLhPgJ+LBarqKhIVla22lNQ3F8hyaSvrc7t0cH9t37iLzXrVLCrCstYHJLs5r2VPzt//ikTAN5n/zdbxzKHYX27aD98lz6mrwGl5Q5f2gI16MBp6JxzAPDx40dHR8eOHTuePXuW+xZo4vNPI88zEnuwp6SkwPfPBQCYTOalS5d69eq1f//+RYsWVVVVBQcH84cqoMbsLiH2Rh2rE8k5XGI/PtT6/JBwc2+SyCs0x+3Vfbt2dVFR6aKiYmZoKPi7Lpw9y32XnpaW4O9SUCQLCxoe4k8QBOHi4nL9+vX8/Pzw8HCSJJ2dnfnvSVEoFN647lz5tc14yZ3LlB831W7q49DBwSEgIMDV1TUlJYXD4ZAkuW3bNvjxgWKi6eeCiomJqfdcX++ubgwZGRlFRcXy8nL+J0oBgHsjUlNTkxeDEI1PnDixY8eOu3btYrFYW7dudXV15f+TIMhHUG/w8vLy5eXl/NMJAYBkTiAnOJoUVZEuK0WhfN61jD875/4brNeZV/Pem7SicpaBdjufE5cT0+v/jirc54hqEvDAEU5RUZG9vX1lZWVkZKSKigr/SptuLrpGnmck9mDn9tlLSkrilaioqFy9erVr165BQUHcrj78fScE1JjdJcTeqGN1IvlVlNiPr61pcfOMCuGHhJv7NEVDhjAX3tz58z/k5Rn06sVfWFJSYtm//6xJk372Lgdn5w95eYOHNewOMoUKIpyrSElJKTk5GQCkpaVtbGy4TyVHRUXxKmhpaX3+/N8zWJmZmR8/fqzZTnFxcUJCAu/HFy9eZGRkGBsbazXku0RDVVVVxcbGampqenh4qKurc7OQshpjuEjIXFD17upGGjt2LADwN8hisaKjo+l0Ou/2X627ol5SUlKenp7Z2dlbt1x4PHwAACAASURBVG49efKkh4cHb5GAH0G9Ro0aBd9vVnJ9/fr19evXDW1H0tj16cHmcB6k/tBJYOfVuD7Ld7G/Xxz9mJvv9VfUQddf//rfeFma9PS9/+QW13PBiU6TrmD/e+9ukP/ev+6KrpNZ2yPIgSOEqqqqSZMmJScnnzlzhnfDfdy4ceHh4dCU559Gnmck9mDnfkzbtm379u0br1BLS+v69etKSkoPHz4cMWKEEF9Ehd5dwu2NulfX+F9Fif34JJ+ZmZkIpyBtcfOMCqH2mSbFpoVM0eTu7v78+XMWi5Wdnb1p0yaSJK2srHhLR44cmZGRsWvXruLi4tTUVE9Pz1ovWjMYjPnz59+/f7+kpOTRo0fTpk2j0WjBwcFNGjmVSrW0tMzMzNy8efPXr1/Lyspu3ry5d+/eatWaYi4ofo8fP1ZTU+NOOFx3zbp3dSOtX79eR0fHy8srMjKyqKgoJSVlypQpX758CQ4O5t2HrXVXCGLu3LmKioorVqxwcnJq3/6/LsICfgT1WrdunYqKipeX17Vr14qLi1+9ejVt2rRWMM7uckfLLurKXn9FRiemFpax8kvKjt55uvXiXX9naykKBQBKWBW/7T0dON5GT0uto6rin67OWQVFs/edrayq63epd0eNd9l5Gd8KH737nPY136xbR245jlIiBEEOHCEsXLjw4sWL+/btq7VDsAjPPzU18jwjmQe7qanpsmXL0tLSLCwsLl68WFJSUlpaGhsbu3TpUgaDoaysHBAQcOTIkYYGA8LuLqH3Rh2rE8mvomR+fKjxJGSiaB7JSrgZTObtJ08Oh4WJO5C63Lp1S19ff9KkSSoqKgYGBpcvX96/f7+fnx+vQmBg4Jw5c9atW9euXbsZM2YsWbJEU1MzNzeXIIhly5Zx75skJCQoKSkFBQX5+vpqamoOHTpUWVn5xo0bw4YNg+/3VhISEj5//kwQxIoVK7hf68+fPw8AdDp92rRp8fHx/CUrVqx49OgRQRBXrlypqqoiCGLDhg13794lCOLWrVslJSUEQfj7+wPAqVOn3Nzcdu7cqa2traOjc/To0SlTpgCAjY0N71HL7du39+7d28DAYOLEidXmgnJycpo/f766urq+vv7Zs2fPnz8/YcKEhu5D7o1g/rFUa26gILv6Z2ruHAAgCGLjxo0A0KdPH+73ck1NzYcPH06ePNnDw0NVVXXgwIElJSXXr193dXXlNVXrrhCEvLz83LlzSZJctGhRtUV1fwSCfPoAoKurGxcXN2DAgHHjxnF/0xYsWGBkZMRisQiCEKJrJte8ebByJfDdhW5uavKMK0tnjDLu4XvqSs+l2watDo16lnzUfZxjPwMA8D11pevCLa8+Z0/f+09yRk5ecenYbccqqzhxbz92WLBh26VY7jjcl5+nAEAnz03csboBIGC8Tc/27QavDnX981zgBJvumv+Oi1/F4eAoJXWo9Xev7gNHkKOvZrOPHz/euXMnAMycOZO/l/aZM2e4kYjk/CPa8wyPxB7s69evj4yM7NKly2+//aakpNS+fXsfHx9zc/Pk5OSoqCg6nT5jxgzufq71LoHId1dD90a9qxPkHF4vif34fubZs2dOTk6nTp0SvCs5kgQE/5+asDCYOBE+5H2r4w2iNWro0G+5ufENeeAXAKaOHfswPj5F4NE8IsNp82cx8G9q8zt27JiLi8uePXt4z8UjsZCSkurfv398fHy9NUeMgOhoAICePWHGDJg0CTp2rK0e92TBf1ARRMHssax+gn4hQaIi8zhJ8c9z1T4LOHUKGv5NuJXB8w9qcQQ5Vz98+HDgwIEAICsr6+zsPHXqVBsbG2lp6Zo1uV9Hw5rmIqaZmZmamhp3wnZRMTEx+fr1ayPHHeJhMpkmJibimmaIIIhTp07xXxFo1BXuChYraP16q4ED9bW1jbt2nT158rVLl/gvW37LywtYvnxo377dNDR66+j8Nn583M+Hx78aFcV9ILKLigqLxeKVp7554zptWq/OnQ3atx8/evRDAZIGhFAjJSXB8uXQqROYmEBwMDRiXHKEEEKiV15e/s8//9jZ2amoqEyfPv369euS3CNXiHlGoc75Zfnn9Xz9+vWECRO4g79xexMQDZwouhk0KuFeuXTpodDQ1Zs2PXv3Lvr+fd3u3V2nTn34fd6vnOzsMdbW50+fXrV+/bO3b89fv06Xk5vi5HTyr79qbW2knd2HvDyb0aP5Cz+8ezd25MgXT5/uOXLkUUpKwJYtOzZvTuOOX4haiP/9738EQWCXtebHPekQBCHgxMv8SBIqKwEAnj+HRYtAWxvMzWHfPvhxPACEJB2ef5DkE/pcXVlZCQDFxcW8XNbT01Myp44XYp7RuueX5Z/X083Nbd68eZ8+fYqPj6dSqUJMFN0MGpVwx96+raevP8TSUlZWVk1d3W/NGh1dXd7SjWvWfEpLW7V+vfUvvzDl5XV0dXfs29dOQ8Pfx+drTo6Aq9gcEFBYULBqw4YhlpYMBkO/Z88tu3dn49W2FmLatGm8obuqDYrUSMTPcbuqNx0xrrqhNmzYwNv/gvQnqRVJQlUVcDjw8CH873+gqgp2dnD0dpdSkKv/zQiJT+PPPy3oYJcEkra7JC2eOjT+XM0dTSsnJ2fv3r1Dhgzp1q2bv79/kUgvkEhJSfHvw/v370dFRfGX1DsUY0On7RR8flkfHx9LS0s5OTlTU1M2m62mpiaCDRa1RiXcw6ytHz944Ovl9fTRI+7XspsPH5p9fyb0SmQkAFiNHMmrT5ORGTxsWHl5+S1uL1EBxERHA8BQviegNTQ1u/Kl9YIjCPzXev4BkD/7t3q1f2tddTP8e/rz4fK4aXdlJVy8CL/tHtgB0n18gK/zF5IUGQDExIl1ZBtIQHXs5NWrV4s7OokjabtL0uIRFW4H7p/hZt6pqamrV6++fPlydHT0vXv36jxhCIrNZvOPf29qampnZ8dfUvdkQ0JM2yn4/LJ17xMJ0ahOLQGbN/cdMODMyZNTHB0BYIC5+dQZM36xtweACharqLBQRkaG8eONPDV1dQDIEWwyxQoWq6S4WEZGhsFg8Jerqqu/S01taLSSPfYJQhJhwwaoY0IGKhU4HJCRgbH9Pk6NnTcyMLK2B3WQmCkDhC1cCObm4g4EISR6qampvr6+dVSQlpaurKzU09Oj0WidOnUaNGhQs8VWh4KCgq1bt547dy49PZ1/NsCfjbXCnUkUfpywlufNmzf8U+RUyxIlU6MSboIgnCdOdJ44kV1ZGRcbu2/nTrfp01cEBs6ZN48mIyOvoFBUWFhSXMyfc3M7k6gLNpkiTUaGwWSWFBeXlJTw7838b8KMo9LwGbUQanNCQ2sppFKBIIDDgaFDYcYMcHYG5sV4iI0CzLYlEh1gvJkZnvIQapUePnxYazmNRquoqNDQ0Jg4ceL48eMtLCyEGLS36Tg4ONy5cyc4OHjy5MlqamoEQWzfvn3hwoU/G5aVO79scXFxWVmZcI88EnXe5Wh+jepSYtSlS+qbNwAgJS09xNJy/99/EwRx4+pV7lLupW7ejwBQwWLF3rolKys7zNpawFUMHzECAPi7oOTl5r5786YxYSOEBEEQIC0NBAH9+sGWLZCZCTduwPTp0MyPn43adHhaCN6fQgihWnCTUQUFhRkzZty5c4c7749ETfgCwk7b2cj5ZYWbKLrpNHbiGz9v7+TExAoWKzcnZ29wMEmSg75PxeezcmXHzp1X+/pGX7lSUlz8PjXVY+7c7KysVRs2cDuWCGLJH38oKSuv8fW9ExNTUlLy5vVrLzc3OXzeHKGmxL2aYGwMGzdCejrcvw+eniDwUYsQQqhpUalUgiDk5OSmTJly5coV7tyrFhYWknZZl0u4aTsbOb+s0BNFN5FGJdxhkZG63bvPnz3buGtXazOzW9HRG4KDf/f25i5Vb9cuIjp6zLhx/suWGevqjrG2Li0p+fvcucnTpwPAvl27uqioJL18mfnlSxcVlS1r13LH4b528SIA9NDS8nJzA4DOOjrnrl7t3bfv/377rV/37ovnzZsxd65+z54VLFYXFRUfD49G7wGE0H+oVOjaFf74A1JS4OlTWLgQtLXFHRNCCCE+MjIyDg4Op0+fzs3NPXLkyMiRI6lUqriDqocQ84zWPb9stUlta37TEHqi6CYi5pkmmwfONImQgDIyBMuwm3GmyVGbDqsy5Y7Nk6DOiBIFZ5pEqE0pLi7mcDgKCgr11mzSmSZR3YgaM02Kf+odhJDkaOnXsy8lpMwIPc19HbvKbeOF27dff8gvKQOApE1eKky53OLSoIt3Lz9/k1VQJE+XNevWcdFoi14dNLhvqWBXbbscG/E4KT2vQFZaaoBuB5fBfUb06kalENsuxW64cAsABup2uLBoOgDcePVu8q6TAKDMoCdvXlht7Y8Df19z7sb1l6nSUtQRhrprJ4wsKmP5hl25l/KRISNtY9R9za8jmLI0XuR1B4YQQlw4i1ML9UOXEu71+FZ4JZgEiezUhBASsVHGelkhfra99QBgyfFLM4f2fbZ2/qWlM6gUAgCyCopHbjh0/knSxkm2r7d4hy+cml9SNnrzkUfvPnPfvuzUlQM3H66bMPL1Fu+7K926a6hO3/vP/bcfAWDhqMFZIX5ytP9GZrHq2TUrxM+4k2ata195+vrvNuYvN3oGjrM5/eDlvEPnV/xzbZnDsBcbPJbYDf079tmmyNu8N9YbGEIIoRbthyvc3G9NZWWEnFyrSrqLiwl5eXEHgRASjPb89VWc6qcgjXnreK/VFRgvN3jW2878keaD9DoDQN8u2hm7fAHA4+iF9LyCPTMdR/TSBYAeWuqhs8f2W7HLL+zK1WWzAOBO8oceWurDDHQAQFZaapWz9ZXnQo6JNGWQCTcXH2/aa+fVuOjE1HDvadwr1tOH9OGWrBk3glt57fmbdQeGEEKoRfsh4dbSAgD48pmi271KPOE0jcwMQqOeCUcRQpKCmxzzCN2Hu2+X6v1jLiWkUAjCxqgbr6SdAkNfSz3hY2ZGfpG2kryVYdfDt58s+vvilEHGJp21qRTinr+7cFth0vm/k46mEvP1lxyTTlq8Ei0l+cTPWYIHJlwMCCGEJMQPCbeBAUhLw8sEaitLuF+9kOptJO4gEELNi7/7BwBUsKsKy1gA0M17a83K77PztJXkN0y07a/T4VT881+DjwOAWbeO0y36jDbpIcTa5WVleK8pBEGlEHS+eKgUgvP9Kr4ggQkRAEIIIcnxQ8ItIwODBsGtaGnHcRXiCkjkKlhw77bUxo3ijgMhJFY0KaoiXbaEVZG2Y6kUpfYRUQkCxpv2Gm/aq7KKcy8lLeR6/Mx9Z1b/au1ubcqtQKEQFewfrkcUlLGaITCEEEItWvWT+9ixcDVKuqS49TxjePUSrayMGDNG3HEghMTNrk8PNofzIDWdv3Dn1bg+y3exORwA6L5o65vMXACQplKGGegccR9PEHDtZSqvsoYCMzO/iPdjdmHJ57yCZggMIYRatOLi4u7du9vb24s7ELGpnnBPnw4cDnHskEyttVsckoQDu2Xt7KBDB3GHghASt+WOll3Ulb3+ioxOTC0sY+WXlB2983Trxbv+zta8S8tLT1x69Tm7gl31tahk19U4koQhPTrzWrDs2TWzoPjPmEclrIoPOd9W/HNVTZ7RPIEhhFDLRZIkh8Ph/HgFgclkStos9E2n+jjcysqwZAls3Sw7dkJFO40Wf2XlzAnai2fUw3+KOw6EULN4/P7z6M1HuK87eW4CgKwQP95SNXnGlaUztl2+53vqSsa3QgW6rFFHjaPu44bq63ArhC90OXzn8dw/w9PzCmSkpXTbqQRNHT1lkAmvhWUOw8or2cFX7q05d8O4k9aacSM+5FxK+JipMW/dgpHmo4z1+NfuZTt4lLHeLxsPcUs05q1b7jjctFuHMVv/4pUsthuyxG5IvYEhhFCLJi8vn5qaWn+91uuHmSa5SktB3wDMh1Rs2lkilphEpbiIsDZV/NWZ2L1b3KEg1Mo040yTqG440yRCqFaSP9Mkk8k0MTG5e/euuAMRvZozTdZys1JODrZvg3+O086coNVc2lJwOODlxiBJYs0acYeCEEIIIdSS5eTkeHh4dOnShUajqaurOzs7P3v2jLvIwsKC+G7atGkAMGLECF5Jfn5+eHg478fy8nIA2LJlC0EQJSUlsbGx3HIpqVY+93ntvQOdnWHZMljmxYi701K3f91K+t0Y6fBzoKoq7lAQQgghhFqsL1++DBgwICwsLCQkJC8vLyYmJi8vz9zcPC4uDgDu3r377NkzBoNhbGwcGhoKAFFRUaampidOnCBJUklJycnJiSRJR0dHXoOLFy8mSZLBYAwePJgkSZIk2Ww2b6mVlZWqqmp8fHzzb2nT+enjOIGBMGYM/G8G80FcC8u5SRK2b6T/uUf24EEwNxd3NAghhBBCLZmvr29aWlpQUNDo0aOZTKahoeHJkydJklywYAG3grGx8aFDhxISEqZPn06SpJubm7W19aRJk4RbHYfD4WbhotsC8ftpwk2hwF9/gbUVMW2sfAvqW8JiEV5zGbuDZENDYfJkcUeDEEIIISSpXr58SfCZP39+rdXCw8MpFAr/oH6ampqGhoaPHz9OT/93PNPx48cvX7787NmzFhYWubm5AQEBQkfFu4IudAsSqK6r13Q6/PMPLF8Oi+cz4u9J+6wsU1OX6HFLHsZL+fvIZaRTL10Ca2txR4MQQgghJMF69epV74VkFotVUFAAAIqKijWXvnnzpsP3oZcDAgKuX79+7969I0eOUHBI0x/V012EIGDdOhgwADy9aMP7S89fXD5tJovBlLiL/O9TKds30iPO0EbYQPhZ6NZN3AEhhBDA+cevgq/ce5uVx6pkA8CtFa762uriDgohhBpARkZGSUmpuLi4rKys7kcbY2JiCgoKjIyM5s2bZ2xsbGxsXHfLBNF6plmsl0DfP8aOheQk8PYmgjfSTXsqLnRnhP9De5tCFeOElBwO5OUSTx5K/blHdvIYeauBii+f0cLD4eoVzLYRahNGbTo8LURShrsqYVWYrdpTLZ4HqeluB8MtDbombfK6v/p/2kry4goPIYQaw9nZmc1mx8bG8hdu3LixU6dOvIcd379/P3v27DNnzkRERNDpdEdHx5ycnLqblZOTq6io4L7u0aPHvn37miJ4CSHoA5FycuDvD56ecPQocS6ctvh3Gt/jpOKkrAK/jAS/CBg1CqhUcUeDEGrtdLw29+qocWHRdP5CkgQOSXJ+vDMb8SSJJMF1+ACGDI2hTnu6bkHzRooQQqKxfv36W7duzZo1a9euXYMGDaqqqvrnn3/WrFlz6NAh7jXv4uJiJyen7du39+zZEwBOnz5tY2Mzbty469evS0tL/6zZvn37xsXFffr0KT09/d27d0OGDOGWW1lZJSQkREVFmZmZNc8GNoOGjUCirAyenuDpCSwWvHoFWVlQVNREgdWDQgElJdDRAR0daEt3JBBCkogpS3uwZl61woxvhQCgwqCLIyKEEBKZdu3aPXjwYO3atfPnz//06ZOSklKfPn3Onz8/YsQIAJg/f/7u3bsBwNHR8cWLF5qampaWlgBw+/ZtGo0WEBDQq1evsWPHcpui0+lTp049duwYAGzfvt3V1dXAwEBFRSU4ONjA4N+p09hsdusbpUTIIf9kZKBPH9FGghBCrUoVp1X9tUAItWUqKipbt27dunVrzUW7du3atWsXf0nNXLnW7LlHjx63b9+uWV5rYUvXwsbYRgghIVxKSJkRepr7+lHA7wHhN26+ekehUAbotA8cb9NFXZlX81tJ2bZLsZefp2R8K5Sj0frpaM8faT5YrzMAhFy/v/psNAA8SE3XmLcOAKgUImOXL3/jH4OXykhL8Zd08twEAN00VN9m5fLWssxh2MJRg9kcTvv5G7gl9n30/3R1bur9gBBCSCxw0BaEUOs3ylgvK8TPtrceAKz459rc4QMT1nvsn+105/UHt4PhvGrZhSUjNxw6+yhx7fiRSZsXXvKZQadJ/xr899+xzwBg3gjTrBA/OZr0QN0OWSF+WSF+Gbt8qzVec3Ufg5dmhfjFrnLLCvEb3rMrhSDur/7fwlGDAUCKQskK8evftf2emY6YbSOEUCuGV7gRQi2D9vz1NTtpcK80c6krMF5u8Ky3nWmDTfp3bQ8AQ/V1bHp1u/A0Oa+4VIUpBwBrw29+zM0PneVkY9QNAORlZfbOchrwx26/sKsjjbqrKzAauQnu1qY3X73bG/1gw6RfuCUPUtM/5xU69DVoZMsIIYQkGSbcCCFRkJEh2FVNugbu5WSeUZsOqzLljs2b0NB2TDpr8V5rKysAQGZBMTfhvpjwGgBG9PpvbFGaFHWIfpd/7r+8mfRugqmR0MFzWRroGGi3Oxn/3MdhqDKDDgC7r8XPtuwvTRX+ZiNRyQZZ2UYGhhBCqElhlxKEkAiQykqUklJxRyEQBboM7zVNigoA3OH8KthVhWUsGWkppiyNv766PAMAsgtLRLL2uVYDyioqD916DACp2Xl3Uz64WDTqCXRKSSmprCSS2BBCCDURTLgRQiJAGPSUyqhnjgMJR5OiKtBlWJXs4vIK/vKcohIAaPe9P0kjp0YbN7CXugLjz1uPK9hVe67fn2jWW0muUdenpTK+EgY9G9MCQgihpoYJN0JIFAYPpr35JO4gGmu0cQ8AuP7yLa+kgl11J/mDrLTUcIOu3BI6Tbrie+eZQf57/7r7tEGroElRZw7t97WoZM/1+2cevHQdPqCRMdPefoJBgxrZCEIINYiZmZm9vb24o2hJMOFGCImCvT0lJ08q7Yu442iU5U7DO6kqrTh97dqLt8XlFanZee4Hw7MKi9dOGMl7YrJ3R4132XkZ3wofvfuc9jXfrFvHhq5l5tC+stJS6y/EDNXX0eEbkVAI0mlfKDl54ODQmEYQQgg1NXxoEiHUcFJSAABVVUCl/ltiakoa6MvdflLoYifGuH7m8fvPozcf4b7u5LnJy3aw75hhvBFOrNf9adOr27F5E9opMK4umxl0KdYv7OqX/EI6TbqfTvvTHlMsenThNRUw3mbR3xcHrw5VYtADJ9h011SrNur2rwN7OfTRrzYO98Ulv/XTac8tUWHKjRvY61jsM/cRAxu5XfTbT8ieBsRAvnbYbIDvHxBCCCHJgCdlhFDDKSoCABQUgIoKr4zwWy7722+lw/uzO2g0QwiXls4QvHI/nfZZIX7VCmuWAIAygx4wbkTAuBE/a6qbhup5bxf+Eu6o24I0ztO/a4cXnzLNu3WqJ+46SaVnyd5/AUeO/FBaUAAAoISPUSKEkATBLiUIoYbT0QEASEn5oXDqVDA3l//nOuCM5vU5cueJu7VpIxuRPxMNAwbA1Kk/lL5+DQDQtWsjG0cIIVEJDw8nvnv9+vWECRNUVVW5P379+hUAcnJyPDw8unTpQqPR1NXVnZ2dnz17xns7i8VauXKlvr6+nJycioqKg4NDREREVVUVAAQGBnLbsbCw4Fa+fPkyt0RNTa3m2tPS0iZOnCgvL6+qquri4vLt27cPHz44ODjIy8traWm5uroWFRXxR153YA2CCTdCqOF0dEBZGeLifigkCAgOlk79RI95KKawJNrfsc9mhJ4uYVUcufOkoLR8TL9GTXZDv/lQ+s1H2L0bqo2acv8+KCtD586NihUhhETHycmJJElHR0cAcHNzmzdv3qdPn+Lj46lUKgB8+fJlwIABYWFhISEheXl5MTExeXl55ubmcd//xMyfP3/Hjh07d+7Mzc1NSkrS19d3dHS8c+cOAKxYsYIkSQbjv1nJbG1tSZLs169frWv39vZeunRpZmbm9u3bjx07NnXqVC8vr4CAgC9fvvj7+x84cGDVqlW8N9YbWINgwo0QajiCgF9+gQsXqpf36weBgfJnomVevK3tbW3dpYQUvUVBh28/CZ3tJEUR/vRLe/VO/uwNWLsW+P6o/CsiAmxtq2fhCCHUOFJSUgSf+/fvR0VF8ZdoamoK0o6Pj4+lpaWcnJypqSmbzVZTU/P19U1LSwsKCho9ejSTyTQ0NDx58iRJkgsWLOC+JTo62tDQ0MbGhk6na2hobN68WU9PT7itmD17dr9+/RgMhouLi6Gh4aVLl7y9vU1MTJhMppubm46OzsWLF3mV6w2sQTDhRggJZfJkiImBtzUSa19fcHFROHJB+kOGOMKSXFMHm2SF+H3etezm8jm9Owr0l6lW0h8yFA+Gw7RpsGxZ9WVv3sCtWzB5cqMCRQi1CrKysiwWS1Stsdlsko+pqamdnR1/SWZmpiDtDBxY/WHx8PBwCoXCP8igpqamoaHh48eP09PTAcDW1vbevXtz586Nj4/n9iR5/fq1paWlEFvRv39/3mttbe1qJe3bt8/I+O8vV72B/UxZWRkA0Ol0/kJMuBFCQrGzA11d4Lv79p99+4hhw5SCj8s8TW72sFo5mafJSsHHiaGWsG9fLYv9/UFXF0aPbva4EEISR0VFJSdH4uYj4+/+AQAsFqugoIDD4SgqKvJfL3/y5AkAvHnzBgB279599OjRd+/eWVtbKygo2Nranjt3Tri1Kygo8F5TKBQqlSonJ8croVKpHA5H8MB+Jjc3FwBUVVX5CzHhRggJhUqFrVvhxAm4fbv6IhoNLkQSc90UD5xjRN4mKtniiK+1ISrZjMjbigfOEXPnQmQk0GjVa9y7BydOQFDQf2M1IoTaMAMDg8TERJKU6MfYZWRklJSUpKSkKisryRqGDx8OAARBuLi4XL9+PT8/Pzw8nCRJZ2fnoKAgXiMUCqWi4ocZgvPz85shsJ95+fIlAOjr6/MXYsKNEBLWmDEwciR4ekJ5efVFVCrs2AEhIYxbT1TW/inz7LU44ms9ZJ69Vln7J+PWEwgJgR07a0mpy8vh999h5EicBAchxGVmZlZYWPjo0SNxB1IPZ2dnNpsdGxvL+ZYBnAAADMdJREFUX7hx48ZOnTqx2WwAUFJSSk5OBgBpaWkbGxvuqCNRUVG8ylpaWp8/f+b9mJmZ+fHjx2YI7Gdu3Lihp6enwjdsLmDCjRBqlF27IC0NZs2CWi+iuLtDyhuqja3i/rMqGw/Tbz+m5BfVUg39BCW/iH77scrGw4r7z1JtbCHlDbi711KPJGHWLEhLg127mj1GhJCE6t27d6dOnc6cOSPuQOqxfv16XV3dWbNmXbp0qaCgIC8vLzQ0dM2aNVu2bJH6PoeXu7v78+fPWSxWdnb2pk2bSJK0srLitTBy5MiMjIxdu3YVFxenpqZ6enq2a9eueQKricPhnD171qHGtQ9Cwu81IIQkXXQ0jBoFfn7g7//TOo8eQXAwnD0DpWUcNeUqNWUOnYYjafwUSVLKKqg5eZTcfJCjw6/jwMMD+J7sqc7fH9atg0uXwNq6GaNECEk6f3//PXv2vH//nr+nskiYmZmpqalFRkYKUjk+Pt7c3Jy/pFrymZeXt3bt2vDw8E+fPikpKfXp02fJkiUjRvw7AVlCQsKePXtu376dlpYmKyurp6c3e/bs2bNnE9//iBQUFCxevDgqKio/P79fv37btm1zd3d//PgxAPj4+Dg5OfGvffny5U5OTgMGDOCVrF+/3sLCYsiQIbySVatW+fv71xtYrS5evGhnZ/fy5UtDQ0P+cky4EUKNtn8/uLnBwoWwaVNdHYjLy+HuXXjyBN6/h2/f4PuzKag6CgWUlKBrV+jbFywsQFb2pzWrqmDpUti2DUJDwdW1GUNECLUA2dnZenp6Hh4ea9asEXcsbQKbze7Tp4+Ojk5ERES1RZhwI4RE4cQJmDULbGzg2DHgewwcNaHCQpg2Da5dg4MHcShAhFCtgoKCli9f/urVKx3uDMGoKe3cuXPx4sUvXryoOVI4JtwIIRGJi4OxY4FCgfXrYfp07DHShEgSjh4FX1/gcODcOfjxXi1CCPFUVlb27t1bW1v78uXL0tLS4g6nNUtOTjY3N3d3d1+/fn3NpfjQJEJIRMzN4dUrGDsWZs8GMzMIC4Mfx2lCIlBRAWFhYGYGs2fD2LHw6hVm2wihOkhLS58+ffrRo0futT5yjUQkLy9vzJgx3bp1++OPP2qtgFe4EUKi9vw5rFwJkZEgJwdWVtCnD3TogP1MGqWwENLT4elTuHEDSkvB3h7WrIHevcUdFkKoZbhw4YKTk9Pq1atXrFgh7lhaocLCQjs7u/T09Pv37/9sgBRMuBFCTSM9HSIi4MYNeP4csrKgsFDcAbVk8vKgoQHGxmBlBY6O0L69uANCCLUwe/bsWbBgwaxZs3bv3o19S0Tow4cPDg4Oubm5165dqzYyCT9MuBFCCCGEWr8LFy5MmTJl4MCBf/75Z5cuXcQdTmtw8eLFmTNnamtrR0REdOzYsY6a2IcbIYQQQqj1c3BwuHv3bkZGRs+ePVeuXFlaWiruiFqwN2/eODg42NnZWVtb37lzp+5sG/AKN0IIIYRQ21FZWblz5841a9bQaLSZM2eOGzeuf//+BI4rJZjS0tLr16//9ddf58+f19fX37Fjh6WlpSBvxIQbIYQQQqhtyc7O3rNnz8GDBz9+/KigoGBoaKimpiZbxzRbbV5hYWF6enpKSkpVVdWgQYPc3d0nTpxYxxzv1WDCjRBCCCHURiUkJMTHx7969erbt2/l5eXiDkdyycvLa2hoGBsbW1paamhoNPTtmHAjhBBCCCHUhPChSYQQQgghhJoQJtwIIYQQQgg1IUy4EUIIIYQQakKYcCOEEEIIIdSEMOFGCLVyxcXFBJ+4uLif1VyyZAmvWmBgYHMGKS5MJpOo04EDB0S7xrCwMIIgZGRkRNssQghJMky4EUKtHJPJJEny6dOn3B8DAgJqrZabm7t3714AmDp1KkmSK1asaL4QhVVcXNy9e3d7e/vGtMDdM46OjmQNw4YNE12w/1JXV+f9jxBCbQQm3AihtoJOp3fu3PnSpUuPHj2quXTbtm31zs1bKyaTaWFhIXi5CJEkyeFwOBxOk65FtDDhRgi1QZhwI4TaCgqFsmzZMgCo2V0kPz9/z549Pj4+4ohLePLy8qmpqRcvXmyi9mNiYubMmSPaNjHhRgi1QZhwI4TakJkzZ7Zv3z4iIuL58+f85Tt27Bg9erSurq64ApM08+fP9/LyaoqW1dTUCILAhBsh1KZgwo0QakNkZGSWLFlCkuTatWt5hcXFxTt37vTz86tZn81mnzp1ysbGRlNTk06nGxkZBQcH87pwbNmyhSCIkpKS2NhY7iOGUlJSdZRz5eTkeHh4dOnShUajqaurOzs7P3v2jLsoPDyc97Ti69evJ0yYoKqqyv3x69ev1WLjr8ybkJnFYq1cuVJfX19OTk5FRcXBwSEiIqKqqqoxOy0wMJC7Fl4PmcuXL3NL1NTUagbz4cOHiRMnKikpqaqq2tvbp6am8rdGpVKVlZUx4UYItS01n5JBCKHW5+nTpwwGgyTJ0tJSDQ0NCoXy6tUr7qINGzZMmDCBJMk7d+7A94cmuS5cuAAA69aty8vLy8nJ2bFjB4VCWbx4MX/LDAZj8ODBNddYa3lGRkbnzp01NDSioqKKiopevnw5bNgwWVnZe/fu8eo4OjoCwLBhw27evFlSUhIfH0+lUnNycmrdLm7lsrIy7o9z5sxRVFS8evVqaWlpZmbm4sWLAeDmzZt175la/zp4enrWvTn9+vVTVVWtGYyjo+O9e/eKi4uvXbtGp9MHDBhQbY09evQIDAysIySEEGpl8Ao3QqhtodPp3t7eHA5n3bp1AFBaWrpt27bly5f/rL6lpaWvr6+ysrKamtqCBQumTJkSHBxcWFgo3Np9fX3T0tKCgoJGjx7NZDINDQ1PnjxJkuSCBQuq1fTx8bG0tJSTkzM1NWWz2bxryXWLjo42NDS0sbGh0+kaGhqbN2/W09MT5I3VRin5/fffG7xt382ZM8fc3JzBYIwYMcLOzu7hw4fVLs+rqampqqoK3T5CCLU4mHAjhNqcefPmqaqqnjhx4u3bt6GhoWZmZr179661pr29/c2bN/lLjI2NKysrExMThVt1eHg4hULhH8hPU1PT0NDw8ePH6enp/DUHDhwoRPu2trb37t2bO3dufHw8tyfJ69evLS0thYtWOAMGDOC95g78kpGRwV9BSkqKv48NQgi1enjKQwi1OUwm08vL648//li1alVMTMz58+d/VrOgoGDr1q3nzp1LT0/Pz8/nlZeWlgqxXhaLVVBQAACKioo1l75586ZDhw68HxkMhhCr2L17t7m5+ZEjR6ytrQFgyJAhbm5uY8eObWg7u3btEmLtXPxbR6PRAKBlDVyIEEIih1e4EUJt0YIFCxQVFY8fP25sbNy/f/+fVXNwcAgICHB1dU1JSeFwOCRJbtu2DQBIkuTVIQii1vfWLJeRkVFSUpKSkqqsrKzZw2/48OGN3y6CIFxcXK5fv56fnx8eHk6SpLOzc1BQUONbplAoFRUV/CX830AapClGG0QIIUmGCTdCqC1SVFT09vZWVFSsY0bJqqqq2NhYTU1NDw8PdXV1bgL9//bu3zVxOIzjeI6SQbs4WMXBDjpIV7OIGJCC6dCtf4FIQbdCFwehQxexuqmD9Y/oJA4OnYqDFMRJCjpYFPFHURCCYMkNgSLe2TvOfu/gfL82v3nykGSIn+HhG13XN8qsVutHEvX5fPf395+sX1xcrFarp6en9Q6ZTOb4+Hi1Wu1+Xzabrd1uS5Iky3IkEjE3D6lUKrt3drlc/X7/4+dwOOz1eru3BYB9QOAGsKdubm5ms1kwGNxWcHBwEA6Hh8NhNpudTCa6rj8+Ppqff1/n9/tfXl5eX1/r9Xq321VV9ZP1dDrt9XpjsVi1Wp3P529vb6VS6fb2NpfLfdVYcyKRaLVay+VyNBrd3d0ZhnF6erp7W03TBoNBoVBYLBadTufq6srhcPxBn+fnZ7vdHgqFmDMBsEf+wk4oAPBvrc9Dn52d/bRm492Yz+cNwxiPx/F43O12y7LsdDqj0aj5rUpJkhRFMU9st9uqqh4eHrrd7mKx+NFw2/p0Or2+vvZ4PLIsHx0daZpWq9XMQ/V6/fdf0Q8PD+uV5m6GzWYzHo+fnJyY+3AHAoFyuWwOw/zyyUiS5HQ6t1XOZrPLy0uXy2WxWEKhUKPRUBTFPCuZTG5ceSqV2nik5+fnZp9Go2Fe2Pv7+yd3BwD/k2/GD38zAAAAAL4KIyUAAACAQARuAAAAQCACNwAAACAQgRsAAAAQiMANAAAACETgBgAAAAQicAMAAAACEbgBAAAAgQjcAAAAgEAEbgAAAEAgAjcAAAAgEIEbAAAAEIjADQAAAAhE4AYAAAAEInADAAAAAn0Hi2yJavBCTLoAAAAASUVORK5CYII=\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.9.0/examples/Frequently asked questions.ipynb 0000644 0002322 0002322 00000107242 14304350474 024557 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.9.0/examples/Playground.ipynb 0000644 0002322 0002322 00000021321 14304350474 021453 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.9.0/examples/Graph MIxin Demo Nested.ipynb 0000644 0002322 0002322 00002216132 14304350474 023455 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": "iVBORw0KGgoAAAANSUhEUgAABLcAAAKHCAYAAABzUqqZAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdf1jV9f3/8fsB5DeCIEimTWWhRog/QmWBQ5GVgYO8/EHOnDPTzUSZcx/D2r5OWurC8lizdG1ufjZTs8SmZR81nUH4c0uzFPJnqKAiQWCCIO/vH12chUcI5Mfx4ON2XefadV7v1/v1er7eXjN88ny93ibDMAxERERERERERETsT76DrSMQERERERERERG5VUpuiYiIiIiIiIiI3VJyS0RERERERERE7JaSWyIiIiIiIiIiYreU3BIREREREREREbul5JaIiIiIiIiIiNgtJbdERERERERERMRuKbklIiIiIiIiIiJ2S8ktERERERERERGxW0puiYiIiIiIiIiI3VJyS0RERERERERE7JaSWyIiIiIiIiIiYreU3BIREREREREREbul5JaIiIiIiIiIiNgtJ1sHIHK7evfdd1m1apWtwxBpEx555BF+9rOf2ToMERERERFpg1S5JVKHzz//nM2bN9s6DBG7t3PnTv7zn//YOgwREREREWmjVLklUg8fHx/efPNNW4chYtciIyNtHYKIiIiIiLRhqtwSERERERERERG7peSWiIiIiIiIiIjYLSW3RERERERERETEbim5JSIiIiIiIiIidkvJLRFpVhs2bKBfv364u7tjMpkwmUwcOXKEgoICHn/8cTp37mxpnzBhgq3Dtbm1a9danoerq6utwxEREREREbE7Sm6JSLPJzs5m7NixxMbGcvHiRY4fP06XLl0AGD9+PDt37uT999/nq6++4te//nWjxy8rK+Pee+8lPj6+uUO3maSkJAzDICYmxtahiIiIiIiI2CUnWwcgIm3HunXrMAyDWbNm4enpiaenJ3l5eRQWFrJz506eeuopQkNDAVi8eDGGYTRqfMMwqK6uprq6uiXCr5Onpyd9+/YlMzOzVecVERERERGR76bklog0m7y8PAD8/Py+s71mK15jeHl5ceLEiSZGKSIiIiIiIm2JtiWKSLO5fv16ve2NTWaJiIiIiIiIfBclt0TuQJcvX2b27NkEBQXh4uJCly5dGD58OH/961+5evWqpV9VVRXr1q0jNjaWwMBA3NzcCA0NxWw219oamJGRgclkYtOmTQC4ublZKrNMJhPh4eEA/O53v7O07dq1y3L/pUuXmDlzJt26dcPZ2Rl/f39GjRrFxx9/bDVHzae8vPym7adPn2bcuHH4+Pjg5+dHfHy8VbVXQ9eVnp6OyWTiypUrZGVlWeZwcqpd9NqQ+GscO3aMxMREvL298fDwICoqStsdRUREREREmkDJLZE7TEFBAeHh4bzxxhuYzWYKCws5ePAg0dHR/OxnP2PFihWWvlu3biUpKYlhw4Zx9OhR8vLymDp1KrNnz2bu3LmWfomJiRiGQUJCAgBXr16lurqa69evU1VVxZ49ewD4zW9+Q2VlJZWVlfzwhz8EID8/n/DwcNavX8/y5cspKipi165dFBUVERERQXZ29k3nqGvulJQUUlJSOHfuHOvWreODDz7gscceq3VPQ9c1Z84cDMPAw8ODBx98EMMwMAyDqqoqS5+Gxg9w/PhxIiIiOHDgABs2bODChQssX76ctLQ0bbcUERERERG5RUpuidxhUlNTOXXqFGazmfj4eLy8vOjUqRPPPvssDz/8sFX/6OhoUlNT6dChAx07diQ5OZnx48djNpv56quv6pzHZDLh4OCAo6Mjjo6OADg4OODk5ISTk5Nli2JqaipnzpzhxRdf5JFHHsHT05OQkBDWrl2LYRgkJyc3an1TpkwhIiICDw8Phg8fTlxcHPv376ewsLBZ1nWjxsQ/b948iouLMZvNxMbG4unpSWhoKKtWrSI/P79R6xQREREREZFvKLklcofZuHEjACNGjLC69t5775GSkmL5Hh8fz86dO636hYWFUVlZyaefftrkeDIyMnBwcCA+Pr5We2BgICEhIRw8eJCzZ882eLyaLZA1unbtCsD58+ctbc25rsbEv3XrVgAeeuihWn07d+5McHBwg+cUERERERGR/9LbEkXuIBUVFZSUlODq6oqXl9d39i8pKWHJkiVs3LiRs2fPUlxcXOv6119/3SzxAHh7e9fZ7/PPP6dLly4NGvPGcZydnQFqnaXVXOtqTPz+/v6Ulpbi6uqKp6enVZ+AgAByc3MbNK+IiIiIiIj8lyq3RO4gLi4ueHt7U15eTmlp6Xf2HzlyJGlpaTz55JPk5uZSXV2NYRi89NJLABiG0eR4fHx8cHJyorKy0nKm1Y2foUOHNmmeGzV2XXW95bEx8bu4uODl5UV5eTllZWVWYxUVFTXrGkVERERERO4USm6J3GEeffRRAN59912ra/369eOXv/wlANevXycrK4vAwEBmzpyJv7+/Jcnz7TcqNtWoUaOoqqoiKyvL6trixYu55557ah3g3lS3si53d3euXbtm+d6zZ09WrlzZ6PhrtoLWbE+sUVhYSE5OTtMXJyIiIiIicgdSckvkDrNw4UK6d+/OL3/5S7Zs2UJpaSlnz55l+vTp5OfnW5Jbjo6OREdHU1BQwAsvvEBhYSFXr15l586dvPbaa80aT1BQEJMnT+a9996jpKSEoqIiVqxYwYIFC0hPT8fJqfl2UN/Kuvr3709ubi55eXlkZ2dz8uRJoqKiGh3/888/j6+vLykpKWzbto2ysjI+++wzJkyYcNOtiiIiIiIiItIAhojc1NKlS43AwEBbh9EiCgsLjZSUFKN79+5Gu3btjLvuustISkoycnNza/W7dOmSMW3aNKNr165Gu3btjE6dOhmTJk0ynn76aQMwAGPAgAHGxo0bLd+//cnOzjZCQkIMR0dHAzBMJpPh6OhojBo1qtY8ly9fNmbPnm306NHDaNeuneHv72/86Ec/MrZt22bpc7M5fvKTnxjZ2dlW7c8884xhGIZVe1xcXKPWVePYsWNGVFSU4eHhYXTt2tX44x//2Oj4a+Tk5BiJiYlG+/btDTc3NyM8PNzYvHmzERMTY5n7iSeeaNof8G3mwQcfNJKTk20dhoiIiIiItE3nTYbRxENzRNoos9nMokWLyM/Pt3UoInYtMjKS/v37s2zZMluHIiIiIiIibU++tiWKiIiIiIiIiIjdUnJLRERERERERETslpJbIiIiIiIiIiJit5TcEhERERERERERu6XkloiIiIiIiIiI2C0lt0RERERERERExG4puSUiIiIiIiIiInZLyS0RsSlPT08iIyNtHYaIiIiIiIjYKSW3RERERERERETEbjnZOgARERERuf2Ul5dz/vx5vvzyS1uHYhfc3Nzw9fUlMDDQ1qGIiIjccZTcEpHvdOnSJdLS0njnnXc4f/483t7eREVF8dvf/pa+ffsCkJGRwaOPPmq559SpU8ydO5f3338fR0dHIiIiMJvNBAUFAZCens6vf/1rALKysjCZTAA4OjpSVVXVpLmPHTvGb37zG3bs2EFRUZFlnI4dO7bgUxIRsX/79u1j3bp1vP/+++Tk5NT6+1gaxs/Pj6ioKEaOHMnYsWPx9PS0dUgiIiJtnskwDMPWQYjcjsxmM4sWLSI/P9/WodhUfn4+ERERlJeX85e//IUhQ4Zw5swZnnrqKfbu3csHH3xARESEpX9iYiKbNm0iISGBuXPn0qdPH7Kzs/nxj3/M/fffz759+2qN7+npSd++fcnMzGy2uX/4wx8yf/58Bg4cyCeffMKDDz5IQUEBHTt2ZNiwYRw6dIgtW7YwePDglntwYhEZGUn//v1ZtmyZrUMRkTpkZmbyq1/9in379tGrVy/i4uIYNGgQPXr0oEOHDrYOzy5cvXqVS5cucejQIXbs2MH27dtp164dKSkpzJ07F3d3d1uHKCIi0lblq3JLROqVmprKmTNn+Mc//sEjjzwCQEhICGvXrqVbt24kJydz4MABq/umTJliSTwNHz6cuLg4NmzYQGFhYYMrqG517rlz5xIdHQ3AoEGDalUeVFdXYxgGyuuLiMC5c+f49a9/zdq1a/nRj35EVlYWP/jBD2wdll2Ljo5m1qxZFBUVsXLlShYtWsSqVatIT09n7Nixtg5PRESkTdKB8iJ3kCNHjmAymWp9ZsyYUe89GRkZODg4EB8fX6s9MDCQkJAQDh48yNmzZ63uCw8Pr/W9a9euAJw/f77B8d7q3AMHDqxzzF27dlFUVFSr4ktE5E700Ucf0b9/f/bv309GRgZbt25VYqsZ+fr68vTTT5OTk0NsbCyPPfYYv/jFL7TVU0REpAWockvkDnL//fc3qmKpoqKCkpISALy9vevs9/nnn9OlS5dabTf2d3Z2Br6pnGrpuT08PBo0h4jInWr9+vVMmjSJ6Oho1q5dS/v27W0dUpvVqVMn/vznPzN69GiSkpI4fvw4b775Jj4+PrYOTUREpM1Q5ZaI1MnFxQUfHx+cnJyorKy0bOe78TN06NBbnqPmIHlbzC0icidat24dSUlJTJ8+nc2bNyux1UpGjBjBzp07OXr0KHFxcZSXl9s6JBERkTZDyS0RqdeoUaOoqqoiKyvL6trixYu55557mrTFwt3dnWvXrlm+9+zZk5UrV7bK3CIid5qDBw8yefJkZs2aRXp6Og4O+lGwNfXv35/t27dz9OhRfvrTn+r8RxERkWain2hEpF4LFy4kKCiIyZMn895771FSUkJRURErVqxgwYIFpKen4+R06zuc+/fvT25uLnl5eWRnZ3Py5EmioqJabO5hw4bh5+fHnj17bjlmERF7dPHiReLj4xk6dCjp6em2DqfZrV271nKepKurq63DqVOvXr1Yv349GzdubJN/DiIiIrag5JaI1CsgIIB9+/aRmJjIjBkz8Pf3p1evXrz99tts2rTJ8uanPXv2YDKZ2LRpEwBubm48++yzwDdbDxcvXgxAv379ah0Qv3TpUvr06UPv3r0ZN24cZrOZ3r17N3nuurY7VlVV6W2JInJHeuaZZ2jXrh1vvPEGjo6Otg6n2SUlJWEYBjExMVbXysrKuPfee61eUGIrw4cPZ8GCBcyfP5+8vDxbhyMiImL3TIb+hSdyU2azmUWLFpGfn2/rUETsWmRkJP3792fZsmW2DkXkjvXvf/+b8PBw1qxZw7hx45ptXE9PT/r27UtmZmazjdlUw4cPJzMzs9aZVqWlpfTt25eePXvy7rvv2jC6/7p27Rp9+vShb9++rF271tbhiIiI2LN8VW6JiIiItHFz587lwQcftFS83mm8vLw4ceLEbZPYgm/eIrxkyRLWrVvHgQMHbB2OiIiIXVNyS0RERKQNy8nJYceOHaSmpta5ZVtsIy4ujj59+vDqq6/aOhQRERG7puSWiIiISBu2YcMGAgMDeeihhxrUv6Kigt/+9rf06tULd3d3fH19GTlyJO+88w7Xr18HID09HZPJxJUrV8jKyrIc5P7tl3xUVVWxbt06YmNjCQwMxM3NjdDQUMxmM9XV1ZZ+GRkZlvtNJhOnT59m3Lhx+Pj44OfnR3x8PCdOnLCK89ixYyQmJuLt7Y2HhwdRUVE33R554/g12xWbY153d3cGDhzI5s2bGT58uGWsKVOmNOhZA0yaNImMjAy9/VdERKQJlNwSERERacO2b9/Oww8/jINDw37smzFjBsuWLePll1/m8uXLHD16lF69epGQkMCHH34IwJw5czAMAw8PDx588EHLizq+naDZunUrSUlJDBs2jKNHj5KXl8fUqVOZPXs2c+fOtfRLTEzEMAwSEhIASElJISUlhXPnzrFu3To++OADHnvssVoxHj9+nIiICA4cOMCGDRu4cOECy5cvJy0tzSohdeP4zTnvxYsXWbVqFWazmcOHD+Pi4oJhGLz++usNetYAjzzyCEVFRRw8eLDB94iIiEhtSm6JiIiItGGHDh1iwIABDe6/Y8cOQkJCiI2Nxc3NjU6dOvHCCy8QHBzc6Lmjo6NJTU2lQ4cOdOzYkeTkZMaPH4/ZbOarr7666T1TpkwhIiICDw8Phg8fTlxcHPv376ewsNDSZ968eRQXF2M2m4mNjcXT05PQ0FBWrVp1yy+CudV5Q0JCWLNmDVeuXLmleYODg2nfvj2HDh26pftFREREyS0RaQPWrl1r2Qri6upq63BERG4bV65c4csvv6Rbt24Nvufhhx/mo48+YurUqezZs8eyFTEnJ4fo6OgGjxMfH8/OnTut2sPCwqisrOTTTz+96X3h4eG1vnft2hWA8+fPW9q2bt0KYLXVsnPnzreUhGvqvP7+/vTq1euW5jWZTHzve9/j7Nmzt3S/iIiIKLklIq1s8ODBxMfHN+uYSUlJGIZBTExMs44rImLvSktLgW/eFthQf/zjH1m9ejUnT54kJiaG9u3b8/DDD7Nx48ZGzV1SUsJvf/tbQkND6dChg+WXEL/+9a8B+Prrr296n7e3d63vzs7OAJZzuioqKigtLcXV1RVPT0+r+wMCAhoVZ3PN26FDh1uaF77586mrkk1ERES+m5JbIiIiIm1UTWKmoedtwTeVRI8//jjbt2+nuLiYjIwMDMNg1KhRvPjii1Z96zJy5EjS0tJ48sknyc3Npbq6GsMweOmllwAwDOMWVgQuLi54eXlRXl5OWVmZ1fWioqJbGrep8168ePGWx3ZwcLjl5yEiIiJKbomIiIjIt/j4+HDs2DEA2rVrR2xsrOXNglu2bKnV193dnWvXrlm+9+zZk5UrV3L9+nWysrIIDAxk5syZ+Pv7WxJhV69ebXKMI0aMAP67TbBGYWEhOTk5TR6/sfMWFBSQm5vbYvOKiIhI/ZTcEhEREZFafv7zn3P48GEqKiq4ePEif/jDHzAMg2HDhtXq179/f3Jzc8nLyyM7O5uTJ08SFRWFo6Mj0dHRFBQU8MILL1BYWMjVq1fZuXMnr732WpPje/755/H19SUlJYVt27ZRVlbGZ599xoQJE266ZbC53GzeI0eO8LOf/YzAwMAWm1dERETqp+SWiNidY8eOkZiYiLe3Nx4eHkRFRZGZmVln/8uXLzN79myCgoJwdnamQ4cOjBgx4qYHHX+XyMhIy7kxJpOJCRMmADB8+PBa7cXFxbe8PhERW/rXv/5Fr169SEpKwtfXl969e7N161b+9Kc/MW/evFp9ly5dSp8+fejduzfjxo3DbDbTu3dvANatW8e0adN4+eWX6dy5M927d2f16tWMHz8egNjYWB544AH27NmDyWRi06ZNALi5ufHss88C32x7XLx4MQD9+vWznNkYFBREdnY24eHhjB49moCAACZNmkRycjKhoaFUVFRgMpmYMmWKpers2+NPmDChWebt1KkT06ZNIzU1le7du+Po6NgyfygiIiJSLydbByAi0hjHjx+3vKp9w4YNREREcOrUKebMmcOJEyes+hcUFPCDH/yAr7/+mtdff50hQ4ZQUFBAamoqMTExrFy5kilTpjR4/szMTA4dOsSDDz7I97//fVasWAHAli1b+OEPf0hKSgpJSUnNtl4RkdYWFhbW4Oqqnj17snv37pte69ixY53jLFy4sNb3us6bqu8cquDg4Jsech8XF9fgcZpz3vz8fDp27FjnfSIiItJyVLklIi3GycmpVjWTyWRi7969bNmyxaq9ods55s2bR3FxMWazmdjYWDw9PQkNDWXVqlXk5+db9U9NTeXUqVMsXbqU+Ph42rdvT3BwMGvWrOGuu+5i5syZXLhwoVHrCgsLY9WqVRw6dIiJEydiGAbTpk0jJiZGiS0RkTasoKAAX19fKisra7WfPn2aEydOWG3bFBERkdah5JaItJiqqioMw6j1GTRoEHFxcVbtBQUFDRqz5hDfhx56qFZ7586dCQ4Otupf89v1G3+T7+LiQkxMDFevXuX9999v9NrGjBnDM888w9tvv01kZCSXL18mLS2t0eOIiIh9+fLLL5k2bRp5eXl8/fXX7Nu3j3HjxtG+fXt+85vf2Do8ERGRO5KSWyJiNyoqKigtLcXV1fWmBwYHBARY9S8pKcHV1RUvLy+r/p06dQJocGLtRmlpaQwaNIiPPvqIMWPG4OCgv1JFRNqywMBAtm/fTnFxMUOGDKFDhw78+Mc/5t5772Xfvn306NHD1iGKiIjckXTmlojYDRcXF7y8vCgtLaWsrMwqwVVUVGTV39vbm5KSEkpLS60SXDXbEW/1DVe7du2ipKSE0NBQpk+fTlhYGGFhYbc0loiI2IeYmBhiYmJsHYaIiIh8i8oMRMSujBgxAvjv9sQahYWF5OTkWPV/9NFHgW8OfP+2iooKduzYgZubm9UWx4Y4deoUTzzxBG+99RbvvPMObm5uJCQkcOnSpUaPJSIiIiIiIrdOyS0RsSvPP/88vr6+pKSksG3bNsrKyvjss8+YMGHCTbcqLly4kO7du5OSksLmzZspLS0lNzeX8ePHk5+fj9lstmxPbKiysjISExNZunQp9913H926dWPDhg2cP3+e0aNHWx00LCIiIiIiIi1HyS0RsStBQUFkZ2cTHh7O6NGjCQgIYNKkSSQnJxMaGkpFRQUmk4kpU6YA32w53L9/P4899hgzZ87Ez8+PgQMHcuXKFbZv386TTz7ZqPlnzJiBl5cXhw8fJiEhgSNHjlBYWEh0dDSVlZXs3r0bZ2dnnnvuuZZYvoiIiIiIiNxAZ26JSKvas2dPk8cIDg62vAXx2258I2INPz8/XnrpJV566aUmz/3KK6/wyiuvWLUbhtHksUVExJqnpyd9+/YlMzPT1qGIiIjIbUqVWyIiIiIiIiIiYreU3BIREREREREREbul5JaICGAymb7zM3/+fFuHKSJyW7p06RIzZ86kW7duODs74+/vz6hRo/j4448tfTIyMmr9nXr69GnGjRuHj48Pfn5+xMfHc+LECUv/9PR0TCYTV65cISsry3Kfk5NTk+fOyclh7Nix+Pn5WdoKCwtb/kGJiIhIi1ByS0SEb87M+q6PklsiItby8/MJDw9n/fr1LF++nKKiInbt2kVRURERERFkZ2cDkJiYiGEYJCQkAJCSkkJKSgrnzp1j3bp1fPDBBzz22GOWcefMmYNhGHh4ePDggw9a/i6uqqpq8tzTpk1j+vTp5OXlsWfPHhwdHS1jDhs2DD8/v2Y5I1JERERah5JbIiIiInLLUlNTOXPmDC+++CKPPPIInp6ehISEsHbtWgzDIDk5+ab3TZkyhYiICDw8PBg+fDhxcXHs37+/URVUtzr33LlziY6Oxt3dnUGDBlFVVUXHjh0BqK6utiTSRERExD4ouSUiIiIiABw5csRqS/aMGTPqvScjIwMHBwfi4+NrtQcGBhISEsLBgwc5e/as1X3h4eG1vnft2hWA8+fPNzjeW5174MCBdY757covERERsQ9O391FRERERO4E999/f6MqlioqKigpKQHA29u7zn6ff/45Xbp0qdV2Y39nZ2fgm8qplp7bw8OjQXOIiIiIfVByS0RERERuiYuLCz4+PpSVlXH16lWrw96bg8lkstncIiIiYh+0LVFEREREbtmoUaOoqqoiKyvL6trixYu55557ah0C31ju7u5cu3bN8r1nz56sXLmyVeYWERER+6DkloiIiIjcsoULFxIUFMTkyZN57733KCkpoaioiBUrVrBgwQLS09ObVFXVv39/cnNzycvLIzs7m5MnTxIVFdVic+ttiSIiIvZH9dsiIiIicssCAgLYt28fv//975kxYwZ5eXn4+PjQr18/Nm3axPDhwwHYs2dPrUPa3dzceOaZZ3juuedqbT3s168fcXFxbN68GYClS5fy5JNP0rt3b3x9fTGbzfTu3bvJcwM3PV+sqqpKb0sUERGxM0puiYiIiEiT+Pr6smTJEpYsWVJnn8GDB9eZMKovkdSzZ092797dYnPfqL65RERE5PakbYkiIiIiIiIiImK3lNwSERERERERERG7peSWiIiIiIiIiIjYLSW3RERERERERETEbim5JSIiIiIiIiIidkvJLREREZFWkp6ejslkwmQy0aVLF1uHY3fWrl1reX6urq62DkdERERuE0puiYiIiLSSOXPmYBgGYWFhtg6lxQ0ePJj4+PhmHTMpKQnDMIiJiWnWcUVERMS+KbklIiIiIiIiIiJ2S8ktERERERERERGxW0puiYiIiIiIiIiI3VJyS0RERKQOGRkZlgPMTSYTOTk5jB07Fj8/P0tbYWEhAJcuXWLmzJl069YNZ2dn/P39GTVqFB9//HGD5qqqqmLdunXExsYSGBiIm5sboaGhmM1mqqurLf0iIyNrxTRhwgQAhg8fXqu9uLi4+R9IKzt27BiJiYl4e3vj4eFBVFQUmZmZdfa/fPkys2fPJigoCGdnZzp06MCIESPYuXNno+e+k56ziIiIvVNyS0RERKQOiYmJGIZBQkICANOmTWP69Onk5eWxZ88eHB0dAcjPzyc8PJz169ezfPlyioqK2LVrF0VFRURERJCdnf2dc23dupWkpCSGDRvG0aNHycvLY+rUqcyePZu5c+da+mVmZvLxxx/j4eFBWFgYK1asAGDLli0MGjSIN954A8Mw8PHxaYEn0nqOHz9OREQEBw4cYMOGDVy4cIHly5eTlpbGiRMnrPoXFBQQHh7OmjVrMJvNFBYWsnfvXtzd3YmJieH1119v1Px3ynMWERFpC5TcEhEREWmguXPnEh0djbu7O4MGDaKqqoqOHTuSmprKmTNnePHFF3nkkUfw9PQkJCSEtWvXYhgGycnJDRo/Ojqa1NRUOnToQMeOHUlOTmb8+PGYzWa++uorS7+wsDBWrVrFoUOHmDhxIoZhMG3aNGJiYkhKSmqp5dfJycmpVjWTyWRi7969bNmyxao9MDCwQWPOmzeP4uJizGYzsbGxeHp6EhoayqpVq8jPz7fqn5qayqlTp1i6dCnx8fG0b9+e4OBg1qxZw1133cXMmTO5cOFCo9Z1uz1nERERuTklt0REREQaaODAgTdtz8jIwMHBgfj4+FrtgYGBhISEcPDgQc6ePVvv2PHx8TfdPhcWFkZlZZ7U2TIAACAASURBVCWffvpprfYxY8bwzDPP8PbbbxMZGcnly5dJS0tr5IqaR1VVFYZh1PoMGjSIuLg4q/aCgoIGjbl161YAHnrooVrtnTt3Jjg42Kr/xo0bAYiLi6vV7uLiQkxMDFevXuX9999v9Npup+csIiIiN+dk6wBERERE7IWHh4dVW0VFBSUlJQB4e3vXee/nn39Oly5d6rxeUlLCkiVL2LhxI2fPnrU6y+nrr7+2uictLY3t27fz0Ucf8be//Q0Hh7bxe8uKigpKS0txdXXF09PT6npAQAC5ubm1+peUlODq6oqXl5dV/06dOgE0OLF2o7b6nEVERNoK/ZdZREREpAlcXFzw8fHBycmJyspKq0qlms/QoUPrHWfkyJGkpaXx5JNPkpubS3V1NYZh8NJLLwFgGIbVPbt27aKkpITQ0FCmT5/OoUOHWmSNrc3FxQUvLy/Ky8spKyuzul5UVGTV39vbm/LyckpLS63612xHbOiWyBu11ecsIiLSVii5JSIiItJEo0aNoqqqiqysLKtrixcv5p577qGqqqrO+69fv05WVhaBgYHMnDkTf39/TCYTAFevXr3pPadOneKJJ57grbfe4p133sHNzY2EhAQuXbrUPIuysREjRgD/3Z5Yo7CwkJycHKv+jz76KPDNge/fVlFRwY4dO3Bzc7Pa4tgQbf05i4iItAVKbomIiIg00cKFCwkKCmLy5Mm89957lJSUUFRUxIoVK1iwYAHp6ek4OdV9GoSjoyPR0dEUFBTwwgsvUFhYyNWrV9m5cyevvfaaVf+ysjISExNZunQp9913H926dWPDhg2cP3+e0aNHU1lZ2ZLLbRXPP/88vr6+pKSksG3bNsrKyvjss8+YMGHCTbcqLly4kO7du5OSksLmzZspLS0lNzeX8ePHk5+fj9lstmxPbKg74TmLiIi0BUpuiYgVwzDYunUrs2fPZty4ccycOZO33nqr3qoDkeZSUVFBRkYGTz31lK1DEWHPnj2YTCY2bdoEgJubm6Wi6tsCAgLYt28fiYmJzJgxA39/f3r16sXbb7/Npk2bGDt2LADp6emYTCYOHTrEuXPnMJlMPPvsswCsW7eOadOm8fLLL9O5c2e6d+/O6tWrGT9+PACxsbH06NGDadOm4eXlxeHDh0lISODIkSMUFhYSHR1NZWUlu3fvxtnZmeeee66VnlLLCAoKIjs7m/DwcEaPHk1AQACTJk0iOTmZ0NBQKioqMJlMTJkyBfhmy+H+/ft57LHHmDlzJn5+fgwcOJArV66wfft2nnzyyUbNP2PGjDviOYuIiLQFJuNmBziICGazmUWLFt30deNt2blz50hMTOTAgQM4OztTWVlJu3btqKqqonv37mzatImQkBBbhyl2JDIykv79+7Ns2bI6+1y/fp2dO3eyZs0a3nzzTcrKyvD39+fixYutGKnI7S0sLIzDhw/j6upKQkICP/nJT3jooYdwdnau857z589z99138+GHHxIZGdmK0UpjREVF0b9/f8xms61DERERsUf5eluiiFiUl5czdOhQTp8+DcC1a9dq/e+ZM2eIjo7m008/JSAgwFZhShuyd+9e3njjDdasWcOlS5do166dZZuPfvciUlvN/yfKy8t56623WL9+PZ6eniQlJTF+/HiGDBmit/iJiIjIHUk/AYmIxcqVKzl16lSdZ4hUVVVRUlLCokWLWjkyaUuOHj3K/Pnz6d69O4MHD2b58uWWg5l1fo1Iw1RVVWEYBqWlpfztb39j6NChBAYGMmvWLDIzM5UcFhERkTuKklsiYrFhwwauX79eb5/KykrWr1/fShFJW1FWVobZbGbgwIHcd999LFy40FIhqISWSNPUVNdeunSJV199laioKLp27crTTz/N8ePHbRzd7cdkMn3nZ/78+bYOU0RERBpB2xJFxOLkyZMN+m1/fn4+169fx9HRsRWiEntlGAZ//etfOXz4MFlZWbWu1fxjvD5FRUX1niUkcqeprq7+zj41yeJz586xePFiFi9eDMBbb73F4MGD631j451CVW0iIiJtj37CERELNze3BvVr166dElvynUwmE6NHj+b555/H0dGRkpISTCYThmE06B+Xzs7ODB06tBUiFbEPe/bs4csvv/zOfjXVR4ZhcPfdd3P27FmGDx+uxJaIiIi0WfopR0QsBg8ezOnTp6mqqqqzj8lkom/fvq0YldgzLy8vOnXqxIgRI5g/fz6bN2/mL3/5C7t378bJyclybtDNeHp68u6777ZyxCK3rz59+tSb3Kr5/9T3v/99xo8fz8SJE3F1deXuu+/G29u7FSNtOWvXruWxxx4DwMXFhfLychtHJCIiIrcDnbklIhZTp06tN7FVY8aMGa0QjbQ1vr6+TJw4kV27dvHFF1/wwgsv8MADDwBo+6HITZSVlXHvvfcSHx9fZ5927doBcPfdd/OrX/2Ko0ePkpuby/z58+nRo0drhXpTgwcPrjf2W5GUlIRhGMTExDTruCIiImLflNwSEYuoqCjmzp1r2dJyIwcHB8aOHctPfvITG0QnbUmXLl2YNWsW+/bt49NPP+V//ud/6Nq1K6BEl0gNwzCorq62OmurJqHl7+/PzJkzOXDgAGfPnmXRokX06tXLFqGKiIiI2JSSWyJSy6JFi/jb3/5Gly5darX7+fmRnp7OmjVrbpr4ErlV9913H2lpaXzxxRfs2bOHX/ziF3Ts2FHnuskdz8vLixMnTli25zo5OdG+fXsmTZrErl27KCgoID09nQEDBtg4UhERERHb0plbImLl8ccf5/HHH+fQoUNERUXx4osvMnnyZBwclA+XljVo0CAGDRrEkiVL2L9/v63DEbmtvPbaa/Tt21fVjSIiIiI30L9URaROwcHBlJaW0qlTJyW2pFU5OjoyePBgW4ch0iIqKir47W9/S69evXB3d8fX15eRI0fyzjvvcP36dQAyMjIsW8RNJhPl5eUMHDiQZcuWWdq6dOnC/v37iYmJwcvLC3d3d4YOHUpWVpaNV9h8jh07RmJiIt7e3nh4eBAVFUVmZmad/S9fvszs2bMJCgrC2dmZDh06MGLECHbu3NmoeYuLi2s9f5PJxHPPPQdAVVVVrfbRo0c3aY0iIiLSdPrXqojUqWZb2I3nvYiIyK2bMWMGy5Yt4+WXX+by5cscPXqUXr16kZCQwIcffghAYmIihmGQkJBQ6945c+ZgGAZhYWEUFxcza9YsnnvuOQoKCti9ezdFRUUMGzaMf/3rX7ZYWrM6fvw4ERERHDhwgA0bNnDhwgWWL19OWloaJ06csOpfUFBAeHg4a9aswWw2U1hYyN69e3F3dycmJobXX3+9wXP7+PhgGAYPPfQQDg4OHD9+nGeffRb4ZnuoYRhERETwj3/8gw0bNjTbmkVEROTWKLklInWqqdaqqSQQEZGm27FjByEhIcTGxuLm5kanTp144YUXCA4ObtQ4V65cYfny5URERODh4cEDDzzA3//+d65du8asWbNaKPqbc3Jysqp02rt3L1u2bLFqDwwMbNCY8+bNo7i4GLPZTGxsLJ6enoSGhrJq1Sry8/Ot+qempnLq1CmWLl1KfHw87du3Jzg4mDVr1nDXXXcxc+ZMLly40Kh1zZ49m+rqal588cVa7VlZWXzxxReMGTOmUeOJiIhIy1ByS0TqpMotEZHm9/DDD/PRRx8xdepU9uzZY/kFQk5ODtHR0Q0ex8PDg759+9ZqCw0NpXPnzhw6dOimCaCWUlVVhWEYtT6DBg0iLi7Oqr2goKBBY27duhWAhx56qFZ7586db5oI3LhxIwBxcXG12l1cXIiJieHq1au8//77jVrXj370I0JDQ/nrX//K5cuXLe0vvPACycnJljdXioiIiG0puSUidar5Lbsqt0REms8f//hHVq9ezcmTJ4mJiaF9+/Y8/PDDluRMQ/n4+Ny0PSAgAICLFy82OVZbqaiooLS0FFdXVzw9Pa2u16zx2/1LSkpwdXXFy8vLqn+nTp0AGpxY+7aUlBS+/vprli9fDkBubi4ffPABU6dObfRYIiIi0jKU3BKRejk4OKhyS0SkGZlMJh5//HG2b99OcXExGRkZGIbBqFGjrLa/1efy5csYhmHVXpPUujEBZE9cXFzw8vKivLycsrIyq+tFRUVW/b29vSkvL6e0tNSqf812xIZuify2n/zkJ3Tq1IlXXnmFiooKlixZwk9/+lM6dOjQ6LFERESkZSi5JSL1cnR0VOWWiEgz8vHx4dixYwC0a9eO2NhYy9sRt2zZ0uBxysvL2b9/f622Tz75hPPnzxMWFsZdd93VrHG3thEjRgD/3Z5Yo7CwkJycHKv+jz76KIDVM6yoqGDHjh24ublZbXFsCBcXF6ZPn87FixdZsmQJ//jHP1r9TDMRERGpn5JbIlIvVW6JiDS/n//85xw+fJiKigouXrzIH/7wBwzDYNiwYQ0ew9vbm3nz5pGdnc2VK1c4cOAAEyZMwNnZGbPZ3ILRt47nn38eX19fUlJS2LZtG2VlZXz22WdMmDDhplsVFy5cSPfu3UlJSWHz5s2UlpaSm5vL+PHjyc/Px2w2W7YnNtb06dNxc3Pj2WefZfjw4Xz/+99v6vJERESkGSm5JSL1UuWWiEjz+te//kWvXr1ISkrC19eX3r17s3XrVv70pz8xb948AEsl16ZNmwBwc3NjwoQJtcbx9PTk5Zdf5ne/+x133XUXQ4YMoUOHDnzwwQf88Ic/bPV1NbegoCCys7MJDw9n9OjRBAQEMGnSJJKTkwkNDaWiogKTycSUKVOAb7Yc7t+/n8cee4yZM2fi5+fHwIEDuXLlCtu3b+fJJ5+85Vg6duzIhAkTMAyD2bNnN9cSRUREpJk42ToAEbm9qXJLRKR5hYWF8dprr9XbJzEx8abnad2oJjF2O9qzZ0+TxwgODr7pQfs3vhGxhp+fHy+99BIvvfRSk+e+UUREBP/+978ZMmRIs48tIiIiTaPKLRGpl4ODgyq3RETkjvfaa6+paktEROQ2peSWiNTL0dFRlVsiInLHef3113n00UcpKyvjtdde48svv2Ts2LG2DktERERuQsktEamXtiWKiNw+0tPTMZlMHDp0iHPnzmEymXj22WdtHZZdMZlM3/mZP38+8M3ZZx06dODVV19l7dq1ODnpRA8REZHbkf4LLSL10oHyIiK3jzlz5jBnzhxbh2HXGnKWWY2aw+pFRETk9qbKLRGplyq3RERERERE5Ham5JaI1EuVWyIiIi3nypUrjaomExEREWvaligi9VLlloiI2EJZWRn9+vWjZ8+ebN682dbhtJi8vDwOHDjAvn372LBhA35+fgQEBBAQEICvr6/l4+fnV+t7TZuDg35XLSIiouSWiNRLlVsiImILhmFQXV1901+weHp60rdvXzIzM20QWfPq1asXffr0ITc3l/Pnz3P+/Hngm4PvnZyccHBwwDAMqqqqbvos/P39yc3NxcfHp7VDFxERuW0ouSUi9VLlloiI2IKXlxcnTpywdRitwsXFhbFjx7J//34+/fRTKisrMQyDysrKeu9zcHAgNjZWiS0REbnjqY5ZROqlyi0REZGW5+bmRmZmJkOGDMHJqWG/f66uriYlJaWFIxMREbn9KbklIvVS5ZaIiHyXS5cuMXPmTLp164azszP+/v6MGjWKjz/+2NInMjISk8lk+UyYMAGA4cOH12ovLi4mIyOjVlt5eTkA6enpmEwmrly5QlZWluV6Q5NBtzsPDw/effddEhISvvMsLUdHRwYOHEh4eHgrRSciInL7UnJLROrl6Oio5JaIiNQpPz+f8PBw1q9fz/LlyykqKmLXrl0UFRURERFBdnY2AJmZmXz88cd4eHgQFhbGihUrANiyZQuDBg3ijTfewDAMfHx8SExMxDAMEhISas01Z84cDMPAw8ODBx98EMMwLOdRfduwYcPw8/Njz549rfMQmpGzszPr1q1j8uTJmEymOvtVV1fz8MMPt2JkIiIity8lt0SkXg4ODtqWKCIidUpNTeXMmTO8+OKLPPLII3h6ehISEsLatWsxDIPk5GRL37CwMFatWsWhQ4eYOHEihmEwbdo0YmJiSEpKaraYqqurLYkve+To6MjKlSv5zW9+U2cfd3d3FixYQFhYGH/+858t1W0iIiJ3IiW3RKReqtwSEblzHDlypNZ2QJPJxIwZM+q9JyMjAwcHB+Lj42u1BwYGEhISwsGDBzl79qylfcyYMTzzzDO8/fbbREZGcvnyZdLS0pp1Hd+uHLNXJpOJ3/3udyxdutSqgqtdu3Y8++yzHDx4kMGDB5OcnExgYCCzZs3iiy++sFHEIiIitqPklojUS5VbIiJ3jvvvv99S8VTzeeWVV+rsX1FRQUlJCdXV1Xh7e1slxv79738D8Pnnn9e6Ly0tjUGDBvHRRx8xZsyY7zxf6k42a9Ys/vrXv+Lo6Gh5TiaTiSeffJL+/fuzYsUKTp8+TWpqKm+//TY9evRg5MiRbN++3caRi4iItB79JCEi9VLlloiI1MXFxQUfHx+cnJyorKy0SozVfIYOHVrrvl27dlFSUkJoaCjTp0/n0KFDjZq3vrOo2qKJEyfy5ptv4ujoiMlk4vHHH8fPz89yPSAggLlz53LixAneeOMNLl++TGxsLAMGDGDlypXasigiIm2eklsiUi9VbomISH1GjRpFVVUVWVlZVtcWL17MPffcU+vA91OnTvHEE0/w1ltv8c477+Dm5kZCQgKXLl1q8Jzu7u5cu3bN8r1nz56sXLmyaQu5zT366KNs3boVT09PZs2addM+zs7OjBkzho8++ogDBw4QEhLCjBkz6NatG08//TTnzp1r5ahFRERah5JbIlIvBwcHVW6JiEidFi5cSFBQEJMnT+a9996jpKSEoqIiVqxYwYIFC0hPT8fJyQmAsrIyEhMTWbp0Kffddx/dunVjw4YNnD9/ntGjR1NZWdmgOfv3709ubi55eXlkZ2dz8uRJoqKiLNft+W2J9Rk2bBiHDh0iNDT0O/sOGDCA1atXc+bMGX7+85/z5z//mR49ejB27Ng291xERESU3BKRemlbooiIfbpw4QJTp05t8XkCAgLYt28fiYmJzJgxA39/f3r16sXbb7/Npk2bGDt2LAAzZszAy8uLw4cPk5CQwJEjRygsLCQ6OprKykp2796Ns7Mzzz33HBkZGZhMJjZt2gSAm5sbEyZMsMy5dOlS+vTpQ+/evRk3bhxms5nevXtbrldVVdn12xLr071790b1v+uuu5g/fz5nz57lT3/6Ezk5OURERPDAAw+wevXqWlV1IiIi9srJ1gGIyO1N2xJFROzP3/72N375y1/i5eXVKvP5+vqyZMkSlixZUmefV1555aaH09eVgKovMdWzZ092795d5/X6rt2pXFxcmDhxIhMnTiQzM5Nly5YxefJknn76aaZOnUpycnKtc7xERETsiSq3RKReqtwSEbEf+fn5JCYm8rOf/YwxY8bojXlyU5GRkaxfv57c3FwmTpzIyy+/zN13383EiRP55JNPbB2eiIhIoym5JSL1UuWWiMjtzzAMVq9eTUhICEeOHGHHjh2sWLECDw8PW4cmt7EePXqwaNEizpw5w7Jlyzh48CB9+vQhMjKSN998U//9FxERu6HklojUS5VbIiK3t9OnT/OjH/3IUq116NAhhg4dauuwxI54enoydepUjhw5wrZt2+jQoQPjxo0jODiYxYsX8+WXX9o6RBERkXopuSUi9VLllojI7ckwDFauXEloaCj5+flkZ2erWkuaxGQyMXz4cP75z3+Sk5NDfHw8aWlpfO9732PatGkcPXrU1iGKiIjclJJbIlIvVW6JiNx+Tpw4QUxMDE899RRPPfUUBw8eZODAgbYOS9qQe++9F7PZzPnz50lLS+P//u//uP/++4mNjeWf//xnm3wTpYiI2C8lt0SkXqrcEhG5fVRXV7Ny5UrCwsK4fPkye/bsYdGiRbi4uNg6NJtYu3YtJpMJk8mEq6urrcNpk9q3b8+sWbM4ceIEGRkZACQkJNCzZ0/MZjNXrlyxcYQiIiJKbonId1DllojI7eHTTz8lIiKCGTNmMGPGDPbv38+AAQNsHVaDDR48mPj4+GYdMykpCcMwiImJadZxxZqDgwMjR45k27Zt/Oc//2Ho0KHMmzePzp07M2vWLE6fPm3rEEVE5A6m5JaI1EuVWyIitlVVVcXixYsZMGAA165dY9++fSxatAhnZ2dbhyZ3qLCwMFasWMHp06eZN28eGzduJCgoiJEjR7J9+3ZbhyciIncgJbdEpF6q3BIRsZ3Dhw8zePBg5s+fz+9+9zsOHDhA3759bR2WCAD+/v7MnTuXU6dOkZGRQXl5ObGxsfTr14+VK1dy9epVW4coIiJ3CCW3RKReqtwSEWl9lZWVLF68mPDwcFxcXPjPf/7D3LlzcXR0tHVoIlYcHR0tWxYPHDjAwIEDmTVrFt26dePpp58mLy/P1iGKiEgbp+SWiNRLlVsiIq3r448/ZuDAgSxYsIAFCxbw4Ycf0qtXL1uHdVs4duwYiYmJeHt74+HhQVRUFJmZmXX2v3z5MrNnzyYoKAhnZ2c6dOjAiBEj2Llz5y3N7+PjYznA/saPg4MDZ8+evdWltRkDBgywbFmcPXs2f//73wkKCmLs2LFkZWXZOjwREWmjlNwSkXqpcktEpHWUl5fz9NNP88ADD+Dl5cXHH3/M3LlzcXDQj2sAx48fJyIiggMHDrBhwwYuXLjA8uXLSUtL48SJE1b9CwoKCA8PZ82aNZjNZgoLC9m7dy/u7u7ExMTw+uuv31IcpaWlGIZh+SxYsACA3//+93Tp0qVJa2xLOnXqxNy5czl58iT/+Mc/yMvLIzIykgceeIDVq1dTWVlp6xBFRKQN0U9LIlIvVW6JiLS8jz76iH79+vHqq6+yZMkSdu3axb333mvrsG6Zk5OTVWXT3r172bJli1V7YGBgg8acN28excXFmM1mYmNj8fT0JDQ0lFWrVpGfn2/VPzU1lVOnTrF06VLi4+Np3749wcHBrFmzhrvuuouZM2dy4cKFJq1z/fr1/L//9/+YNGkSqampTRqrrXJ2dmbMmDFkZ2dz4MAB7rvvPp544gnuuece5s+fz6VLl2wdooiItAFKbolIvVS5JSLScr7++muefvpphgwZQrdu3fjkk0+YNWtWs1Vr1bxRsbWrZKqqqmpVNxmGwaBBg4iLi7NqLygoaNCYW7duBeChhx6q1d65c2eCg4Ot+m/cuBGAuLi4Wu0uLi7ExMRw9epV3n///Uatq7i4GE9PTwD27t3LT3/6U4YMGcKKFSsaNc6Nrl27dke8/XLAgAGsXr2aM2fOMG3aNF555RW6du3K2LFj2bt3r63DExERO6bklojUy8HBQZVbIiIt4MMPP6Rv376sWLGC5cuX895773HPPfc06xze3t44ODhQVFTUrOO2toqKCkpLS3F1dbUkl74tICDAqn9JSQmurq54eXlZ9e/UqRNAgxNrN/riiy9ISEiga9euvP32201OTBUVFdGhQ4cmjWFPOnfuzPz58zl79iwrV67k6NGjDB482LJlsaqqytYhioiInVFyS0TqpW2JIiLN66uvvmLWrFlER0cTHBzMkSNHmDp1aovM1a5dO7p3785nn33WIuO3FhcXF7y8vCgvL6esrMzq+o3JOxcXF7y9vSkvL6e0tNSqf812xIZuify20tJS4uPjqaysZPPmzfj6+jZ6jG+7evUqp06dumn1WVvn6urKxIkT+eSTT/jwww/p0aMHkydP5nvf+x7z58+3+6SsiIi0HiW3RKRe2pYoItJ8tm7dSmhoKP/7v//Lq6++yubNm7n77rtbdM6BAweye/fuFp2jNYwYMQL47/bEGoWFheTk5Fj1f/TRRwHYsmVLrfaKigp27NiBm5ub1RbH73L9+nWSkpI4duwYb731Vq2E1OjRo8nIyGjUeABZWVlcv36d8PDwRt/blkRGRrJ+/XpycnJ4/PHHWbZsGXfffTcTJ07kyJEjtg5PRERuc0puiUi9VLklItJ0xcXFTJs2jREjRjBo0CBycnJarFrrRo888gi7d+/m8uXLrTJfS3n++efx9fUlJSWFbdu2UVZWxmeffcaECRNuulVx4cKFdO/enZSUFDZv3kxpaSm5ubmMHz+e/Px8zGazZXtiQ/3yl7/k3XffZeXKlURHRzfLujZu3Mj999/P9773vWYZz94FBQWxaNEizpw5g9ls5sCBA4SGhhIZGcmbb76pX7iJiMhNKbklIvVS5ZaISNNs2bKF+++/n02bNrFhwwbWr1+Pv79/q82fmJiIm5sbf/nLX1ptzpYQFBREdnY24eHhjB49moCAACZNmkRycjKhoaFUVFRg+v/s3XlYVeX6PvB7g4LMIEdBQWWIQRFRMTTFIhnUFMUByUyOU1BpYqhBWobYKTjqSSwj0L4lahZaoVuzgNRCxAESGQxQFAcERVEcUZD390c/diHIJLAY7s91cXWx9hrud+2VbB6e9S6ZDPPmzQPw1y2Hx48fx/Tp07Fw4ULo6+vDwcEBd+/eRXx8PF577bUGHT8lJQWffvopAGD27NnVnvr4/fffN3hMt2/fxrZt2/Dvf/+7wdu2d1paWvDx8UFGRgbi4uKgp6cHLy8vWFlZITQ0FDdv3pQ6IhERtSIyIYSQOgRRaxQWFoaQkJAaHy/ekbz99ts4duwYEhMTpY5CbZSjoyMGDx6M9evXSx2FqEXduHEDgYGBiIyMhKenJ8LDw6Gvry9JlsDAQGzatAk5OTlPPUcUNZ13330XEREROHPmDN+XesjJycGGDRvw5ZdfQklJCdOnT8fbb78Na2trqaMREZG0Cti5RUS1YucWEVHD7dixA1ZWVpDL5YiJiUF0dLRkhS0AWL58OVRVVbFixQrJMlBVubm5+OSTTxAcHMzCVj1ZWloiLCwM+fn5WLVqFX755RfYBgg+7AAAIABJREFU2NjA1dUVcrkc/Js9EVHHxeIWEdWKc24REdXflStXMHXqVHh5eWHMmDHIzMzExIkTpY4FLS0tfPTRR/jiiy+QkJAgdZwOr7y8HD4+PrCwsMDrr78udZw2R0dHB35+fjh79qxiEv8JEybA2toaYWFhuHfvnsQJiYiopbG4RUS1YucWEVH97NixAzY2NkhJSUFsbCyioqKgp6cndSwFb29vTJw4EZMnT0Zubq7UcVqNx+fOqukrKCioSY+5cOFCHD16FJs3b0anTp2adN8diZKSEtzd3REXF4c//vgDTk5OePfdd9GzZ0/4+fnh/PnzUkckIqIWwuIWEdWKnVtERLUrKCiAh4cHvLy8MGXKFKSnp8PFxUXqWNXIZDJs2bIFffr0gbu7O4qKiqSO1CoIIer8asri1po1axAREYEtW7Zg8ODBTbbfjm7QoEGIiIhAXl4e3n33Xfzwww8wMzODu7s74uPjpY5HRETNjMUtIqoVO7eIiGomhEBUVBRsbGyQkZGB/fv3IyIiApqamlJHeyJ1dXXs3r0bDx48wLBhw3Dq1CmpI3UYjx49wuLFi/HOO+9g7dq1mDRpktSR2qXu3bsjICAAubm5+Pbbb1FcXAxXV1cMHjwYkZGRuH//vtQRiYioGbC4RUS1YucWEVF1eXl5cHNzw+zZs+Hp6YmTJ0/CyclJ6lj10rNnTxw5cgQ9e/bE8OHDsWvXLqkjtXtFRUWYNGkSPv/8c2zbtg2LFi2SOlK7p6KiAk9PTyQmJiI5ORn9+/fHggULYGJigsDAQFy6dEnqiERE1IRY3CKiWrFzi4job0IIREZGwtbWFgUFBUhKSkJERAQ0NDSkjtYg3bp1Q3x8PKZMmQIPDw+MHz8eOTk5Usdqd8rLyxEWFgZLS0ucOHECBw4cwPTp06WO1eHY29sjKioKFy5cwBtvvIEvv/wS5ubmmDZtGpKSkqSOR0RETYDFLSKqlZKSEju3iIgA5ObmwtnZGfPnz8f8+fORkpICBwcHqWM1mqqqKr788kscOHAAFy9ehK2tLf7973/jt99+4x81nlJ+fj7WrVuHfv36ITAwEG+++SaysrIwbNgwqaN1aIaGhggKCsKlS5ewceNGZGdnY/jw4RgyZAiioqJQVlYmdUQiImokPp6FiGqlrKzMX3KIqEOrqKjApk2b4O/vD3Nzcxw5cgT29vZSx2oyTk5O+OOPP7B582Z89tlncHJygq6uLuzt7WFmZgY9PT3IZDKpY7Z69+7dw9WrV5GWloasrCxoaWnhlVdewdKlS2FmZiZ1PPoHVVVVeHt7w9vbG4cOHcL69esxd+5cBAYGwsfHBwsWLMC//vUvqWMSEVEDsLhFRLVi5xYRdWSZmZmYM2cOTpw4AX9/fwQHB0NFRUXqWE1OWVkZc+bMwZw5c3D69Gn8/PPPOHnyJM6dO4cTJ05ACCF1xGZ169YtlJWVQV9fv9H7UFNTg76+PiZNmoSRI0fCyckJXbp0acKU1BwcHR3h6OiIc+fOISIiAp9++ilCQkIwbdo0LFmyBAMGDJA6IhER1QOLW0RUK3ZuEVFHVF5ejrVr1+KDDz5A3759cezYMQwcOFDqWC3CwsICFhYWUsdoUUFBQVi3bh1SUlLQtWtXqeOQBExNTRESEoL33nsP33zzDdavXw87OzuMGDECfn5+mDRpEjp14q9OREStFefcIqJasXOLiDqatLQ0DBs2DEFBQVi5ciWSk5M7TGGro1qyZAlUVFTwySefSB2FJKapqQkfHx+kp6cjLi4OPXv2xPTp02FlZYXQ0FAUFxdLHZGIiGrA4hYR1YrFLSLqKMrKyhAaGopnn30WqqqqOHHiBAICAqCsrCx1NGpmmpqaWLx4MdatW4erV69KHYdaAZlMBhcXF0RHRyMrKwuenp4ICQlBnz594Ovri1OnTkkdkYiI/oHFLSKqFW9LJKKOIDU1FQ4ODggODkZwcDASEhJgbW0tdSxqQQsXLoS2tjb++9//Sh2FWplnnnkGISEhOH/+PNauXYvffvsN/fv3h6urK+Ryebufk46IqC1gcYuIasXOLSJqz0pLSxEYGIghQ4ZAS0sLqampCAgIgJISPyJ1NGpqanjnnXewYcMGXLp0Seo41Appa2vDx8cHp06dQmxsLLp06YKJEyfCysoKYWFhuHPnjtQRiYg6LH5yI6JasXOLiNqrw4cPY9CgQQgPD8fatWtx8ODBDjeROlX1+uuvo1u3bvjwww+ljkKtmJKSElxcXCCXy/Hnn39i7NixWLZsGYyMjODn54e8vDypIxIRdTgsbhFRrdi5RUTtzb179xAYGIiRI0fCxMQE6enp8PPzY7cWQVVVFatWrcKmTZuQnp4udRxqAyq7ti5fvozg4GDExMTA3Nwc7u7uiI+P5y2LREQthJ/iiKhW7NwiovYkISEBAwcOREREBMLDw7Fv3z707t1b6ljUinh7e8Pe3h6LFi2SOgq1ITo6OvDz88O5c+cQExOD0tJSuLq6YtCgQYiMjMS9e/ekjkhE1K6xuEVEtWLnFhG1B7du3YKfnx+cnJxgaWmJjIwM+Pj4SB2LWiGZTIZ169bhwIED2LVrl9RxqI1RUlKCu7s74uLikJKSgqFDh8LPz09xy+KFCxekjkhE1C6xuEVEtWLnFhG1dT///DNsbW2xZcsWhIeHY8+ePTAyMpI6FrVizz33HLy8vODv748HDx5IHYfaqMGDByMiIgJ5eXkIDAzE999/DzMzM8Uti0RE1HRY3CKiWrFzi4jaqps3b8LX1xdjx47F0KFDkZ2dzW4tqrfVq1fjypUr+PTTT6WOQm2cgYEBAgICcPbsWWzfvh3Xrl2Dq6srhgwZgsjISJSWlkodkYiozWNxi4hqxc4tImqL9u7di/79+2PXrl3YuXMnoqOj0a1bN6ljURtibGyMxYsX48MPP0RhYaHUcagdUFFRgaenJ5KSkpCcnIx+/fph/vz5MDExQWBgIPLz86WOSETUZrG4RUS1YucWEbUlN27cgK+vL8aPH4/hw4cjMzMTU6ZMkToWtVEBAQHo2rUrFi5cKHUUamfs7e0RFRWFCxcu4PXXX8eXX34JMzMzTJs2DUeOHJE6HhFRm8PiFhHVSllZGUIIPsqaiFq9HTt2wMrKCnK5HDExMYiOjoa+vr7UsagNU1dXx6ZNm7Bz505OLk/NokePHggKCsKlS5ewceNGZGVl4bnnnsOQIUMQFRWF8vJyqSMSEbUJLG4RUa2UlP76Z4K3JhJRa3XlyhVMnToVXl5eGDNmDDIzMzFx4kSpY1E7MWrUKMyYMQNvvvkmSkpKpI5D7ZSqqiq8vb2RlpaGhIQEmJmZYc6cOejduzeCgoJw/fp1qSMSEbVqLG4RUa2UlZUBgLcmElGrtGPHDtjY2CAlJQWxsbGIioqCnp6e1LGonVm3bh3Ky8vx3nvvSR2FOgBHR0dER0cjJycH3t7eWL9+PYyNjeHt7Y2MjAyp4xERtUosbhFRrdi5RUStUUFBATw8PODl5YUpU6YgPT0dLi4uUseidkpfXx9r1qzB559/jsTERKnjUAdhZmaGkJAQnD9/HmFhYUhJSYGtrS0cHR2xY8cOfjYjIvoHFreIqFbs3CKi1kQIgaioKNjY2CAjIwP79+9HREQENDU1pY5G7dzMmTPh6uoKX19flJaWSh2HOhAtLS34+PggPT0dcXFx0NPTg5eXF6ysrBAaGoobN25IHZGISHIsbhFRrdi5RUStRV5eHtzc3DB79mx4enri5MmTcHJykjoWdSCRkZHIz8/H0qVLpY5CHZCSkhJcXFwgl8uRnZ2NcePGYdWqVejTpw98fX3x559/Sh2RiEgyLG4RUa0qi1vs3CIiqQghEBkZCVtbWxQUFCApKQkRERHQ0NCQOhp1ML1798bGjRuxYcMGyOVyqeNQB2ZhYYGwsDBcvnwZq1atQmxsLPr37w9XV1fI5XI+5ZqIOhwWt4ioVrwtkYiklJubC2dnZ8yfPx/z589HSkoKHBwcpI5FHdjUqVMxc+ZMzJ07FwUFBVLHoQ5OW1sbfn5+yM3NRUxMDABgwoQJsLa2RlhYGO7evStxQiKilsHiFhHVirclEpEUKioqEBkZCTs7O1y/fh1HjhxBSEgIVFVVpY5GhA0bNkBPTw+zZs1ihwy1CkpKSnB3d0dcXBxOnDgBJycnvPvuuzAyMoKfnx/Onz8vdUQiombF4hYR1YqdW0TU0jIzM/Hcc89hwYIFWLBgAY4fPw57e3upYxEpaGpqYtu2bThw4ADWr18vdRyiKgYOHIiIiAicP38e7777Ln788UeYmZnB3d0d8fHxUscjImoWLG4RUa3YuUVELaW8vByhoaGwt7fHw4cPcezYMYSEhEBFRUXqaETVDBkyBCtWrEBAQACOHDkidZxWbcmSJXyiqQS6deuGgIAA5Obm4ttvv8WNGzfg6uqKwYMHIzIyEvfv35c6IhFRk2Fxi4hqxc4tImoJaWlpGDZsGIKCgrBy5UokJydj4MCBUsciqtWyZcvg6uqKSZMmIT8/X+o4DbZmzRrIZDLIZDIYGxvXuZzaps6dO8PT0xOHDh1CcnIy+vfvjwULFsDExASBgYG4dOmS1BGJiJ4ai1tEVCt2bhFRcyorK0NoaCieffZZqKqq4sSJEwgICFAU1olaMyUlJXzzzTfo2rUrpk6digcPHkgdqUGWLFkCIQTs7OzqtZzaPnt7e0RFReHChQvw9/fHli1bYG5ujmnTpuHw4cNSxyMiajQWt4ioVuzcIqLmkpqaCgcHBwQHByM4OBgJCQmwtraWOhZRg2hpaeGHH35AVlYWfHx8pI5DVC+GhoYICAjA2bNnsXXrVly4cAEjRozAkCFDEBUVhbKyMqkj1pumpiYcHR2ljkFEEmNxi4hqxc4tImpqpaWlCAwMxJAhQ6ClpYXU1FQEBAQo/r0hamusrKzw7bffYtu2bfj888+ljkNUb6qqqvD09MSRI0eQnJyMfv36Ye7cuejduzeCgoJw7do1qSMSEdULP0USUa3YuUVETenw4cMYNGgQwsPDsXbtWhw8eBAWFhZSxyJ6aqNHj0ZQUBAWLVqE/fv3Sx2HqMEqb1k8f/48fH198dlnn8HY2Bje3t44efKk1PGIiGrF4hYR1YqdW0TUFO7du4fAwECMHDkSJiYmSE9Ph5+fH7u1qF1Zvnw5pk6dikmTJiElJaVR+/Dw8FBM5i6TyarcbvXrr79CJpNBLpcrli1atKjK+uXl5SgvL8d3330HV1dXGBoaQk1NDba2tggLC3uqP1Zt3bq1yrFkMhkKCwsbvb8nycrKgoeHB3R0dKCurg4HBwfs2bMHLi4uiuPOmzdPsf7169fh7+8Pc3NzqKioQE9PD2PHjsWBAweaPFtH0LNnTwQFBeHSpUuIjIzEiRMnMHDgQDg6OmLHjh0oLy9v9gwPHjzAihUrYG1tDXV1dXTt2hXu7u7YvXu34jNp5YMP7t69i8TERMW10alTpyr7qs/18fhDFI4fPw5nZ2doaWlBXV0dL774IhITE5t93ET0FAQR1WjdunXC0NBQ6hiSy8zMFABERkaG1FGojRoxYoR46623pI5BEvr999+FhYWF0NXVFREREVLHIWpWDx8+FGPHjhX/+te/xJ9//tmofWzYsEEAENu2bauyfNasWQKA8PLyqrL8xx9/FM7Ozorv5XK5ACA++ugjUVxcLIqKisT69euFkpKSWLJkSbXj2dnZCSMjozqXl5eXC39/f+Hq6iqKi4vrPZ7FixcLDQ2Neq17+vRpoaurK4yMjERsbKy4ffu2yMjIEC4uLqJbt25CVVW1yvoFBQXC1NRUGBgYCLlcLkpKSkR2draYPHmykMlkYuPGjfXOSU+WkJAgPD09hbKysjA1NRUhISHi+vXrzXa8efPmCR0dHREbGyvu3bsnCgsLxZIlSwQAceDAgSrramhoiBEjRtS4n4ZeH3Z2dkJDQ0M899xz4vDhw+LOnTvi+PHjYsCAAUJFRUUcPHiwuYZMRE/nMotbRE/A4tZf/vzzTwFAnDx5Uuoo1EaxuNVxlZSUiIULFwolJSUxbtw4cenSJakjEbWIu3fvCkdHR2FsbCzy8vIavP3169eFioqKGDNmjGLZvXv3hJ6ennjmmWeEmpqauHXrluK1SZMmic2bNyu+l8vlwsnJqdp+X331VdG5c2dRUlJSZXl9ils3btwQo0ePFn5+fqK8vLxB42lIccvT01MAEDt37qyy/OrVq0JdXb1acauy4Ld9+/Yqy0tLS0XPnj2FmpqaKCwsbFBeerIzZ86IgIAAoaurKzQ1NYWPj0+z/AHU1NRUDB8+vNpyS0vLBhW3Gnp92NnZCQDixIkTVdZPS0sTAISdnV0jR0REzewy7wUgolpxzi0iaoyff/4Ztra22LJlC8LDw7Fnzx4YGRlJHYuoRairq2PPnj3Q19eHq6srrl692qDtu3btipdeeglxcXGK2/527dqFoUOHYv78+bh//z5++OEHAEBxcTEOHjyIyZMnK7YfP358jbfk2dnZoaysDJmZmQ3Kk52djaFDh0JJSQnr1q1TfDZoDj///DOAv+Yw+6du3brV+DTVH3/8EQAwbty4KstVVVXh7OyM+/fv45dffmmmtB2Pubk5QkJCcOHCBaxduxa///47+vfvr7hlsammsRgzZgwOHz4MHx8fHDlyRLHf7OxsODk51Xs/jbk+NDQ0MHDgwCrLbG1t0bNnT5w8eRIFBQWNGBERNTcWt4ioVpxzi4ga4ubNm/D19cXYsWMxdOhQZGdnw8fHR+pYRC1OR0cHe/fuxcOHDzFhwgSUlJQ0aHtvb288evQI33zzDQBgy5Yt8Pb2xvTp06GsrIxt27YBALZv347x48dDU1NTsW1JSQlWrFgBW1tb6OnpKeYSWrp0KYC/5sCrrxs3bsDDwwPGxsbYt28ftm7d2qBxNMSDBw9w+/ZtdOnSpcp4Kunp6VVbv6SkBF26dIGWlla19Q0MDACgWeYF6+i0tLTg4+ODzMxMxMXFQU9PD15eXrC2tkZoaChu3rz5VPvfsGEDoqKicPbsWTg7O0NbWxtjxoxRFKvqo7HXh66ubo376969OwA0uFhNRC2DxS0iqhU7t4iovvbu3Yv+/ftj165d2LlzJ6Kjo9GtWzepYxFJxsjICLGxsbh48SJGjRqFoqKiem87btw4dO3aFVu2bEFRURGOHDkCDw8PGBgYwM3NDfv370dBQQE2b94Mb2/vKtu6u7tj1apVeO2115CTk4OKigoIIfDJJ58AAIQQ9c7RqVMnxMfHY9euXbC1tcVrr72G48eP13v7hlBVVYWWlhZKS0tx586daq8/XlRQVVWFjo4OSktLcfv27WrrX7lyBQBgaGjYLHnprz+Curi4QC6XIysrCy+99BJWrVqFPn36wNfXF1lZWY3ar0wmw8yZMxEfH4+bN28iJiYGQghMnjwZ//vf/6qtW5PGXh/Xr1+v8f+RyuuvsshFRK0Li1tEVCt2bhFRXW7cuAFfX1+MHz8ew4cPR2ZmJqZMmSJ1LKJWwdLSEomJibh16xaef/55XLp0qV7bqaiowMvLC6mpqVi+fDkmTpwINTU1AMDMmTPx6NEjfPDBBygoKMCoUaMU2z169AiJiYkwNDTEwoUL0a1bN8Uv//fv329wfi0tLRgZGUFTUxO7d++GpqYmPDw8mu3WrLFjxwL4+/bESoWFhcjJyam2/qRJkwD8VVz/pwcPHuDXX3+FmppatVscqXlYWloiLCwM+fn5CA4Oxi+//AIbGxu4urpCLpc3qKiqq6urKIx17twZrq6uiImJgUwmq/Zeq6ur4+HDh4rvraysEBkZCaBx10dpaWm1Am56ejouX74MOzs79OjRo97jIKKWw+IWEdWqsrjFzi0iqsmOHTtgZWUFuVyOmJgYREdHQ19fX+pYRK2KiYkJEhIS0LlzZzg6OuL06dP12m7mzJkAgI0bN1bpzvLw8ICWlhY2btyIGTNmKH5WA391XDs5OaGwsBCrV6/GtWvXcP/+fRw4cABffPHFU49j586dKCoqwuTJk/HgwYOn2l9NPvroI3Tt2hWLFi1CXFwc7ty5g4yMDMyePbvGDqyPP/4YpqamWLRoEfbs2YPbt28jJycHr7zyCgoKChAWFqa4/Yxaho6ODvz8/HD27FnExMQAACZMmIC+ffsiLCys3rfFvv7660hLS8ODBw9w9epV/Pe//4UQokoxFwAGDx6MnJwcXLx4EUlJSTh79ixGjhwJoHHXh46ODpYtW4akpCTcvXsXycnJePXVV6GiooKwsLAmOENE1CyknM6eqDXj0xL/cvnyZQFAJCQkSB2F2ig+LbF9KiwsFFOmTBEymUzMnDlTFBcXSx2JqNUrLi4Ww4YNE4aGhvV+CrGFhYXo3bu3qKioqLK88ilwmZmZ1bYpKioSvr6+olevXqJz587CwMBAzJo1SwQGBgoAAoCwt7cXq1evVnxf+bV8+XKxffv2ass/+eQTkZSUVG35jBkz6hxDQ56WKIQQ2dnZwsPDQ2hrawt1dXUxfPhw8dtvvwknJyehrq5ebf1r166JRYsWCVNTU9G5c2eho6MjRo8eLX799dd6H5Oa1x9//CF8fHyEmpqa0NHREQsXLhTnz59/4vqpqanC19dX9O3bV6irq4uuXbuKYcOGiY0bN1b7fyErK0uMHDlSaGhoiF69eokNGzZUeb0h10flE0JPnTolRo8eLbS0tISampp44YUXxKFDh5rmZBBRc7gsE6IB/aFEHUhYWBhCQkI6/BNRrly5AkNDQxw8eBAvvPCC1HGoDXJ0dMTgwYOxfv16qaNQE9mxYwfeeOMNReeIi4uL1JGI2oxbt27B3d0dGRkZ2LlzJ1588UWpIzW7JUuW4IsvvqhxHq2GsLa2xv3793H+/PkmSkYt7erVq/jqq6/w2Wef4fLly3jppZfg5+fXan6ODBw4ENeuXav37cNE1GoU8LZEIqoVJ5QnokoFBQXw8PCAl5cXpkyZgvT09FbzCwlRW6GtrY2ff/4ZLi4ucHNzw7p166SO1KoUFhaia9euKCsrq7I8Ly8Pubm51W5Jo7ale/fuCAgIQG5uLr799lsUFxfD1dUV9vb2iIyMRGlpqdQRiaiNYnGLiGrFCeWJSAiBqKgo2NjYICMjA/v370dERAQ0NTWljkbUJqmpqeG7777Dhg0bsHTpUrzyyiv1noeoI6h8SMXFixdx7949HDt2DF5eXtDW1sb7778vdTxqAioqKvD09ERiYiKSk5NhY2ODBQsWwMTEBIGBgcjPz5c6IhG1MSxuEVGt2LlF1LHl5eXBzc0Ns2fPhqenJ06ePAknJyepYxG1Cz4+PoiLi0N8fDyGDx+Oc+fOSR1JcoaGhoiPj8fNmzfx/PPPQ09PDxMmTICFhQWOHTsGMzMzqSNSE7O3t0dUVBTOnz+P119/HV9++SXMzMwwbdo0JCUltUiGNWvWQCaT4eTJk8jPz4dMJsN7773XIscmoqbB4hYR1YqdW0QdkxACkZGRsLW1RUFBAZKSkhAREQENDQ2poxG1K05OTkhKSkJFRQUcHBwQGxsrdaQmt2bNmgbNt+Xs7IwffvgB586dw4MHD1BYWIitW7fC3Ny8GVOS1Hr06IGgoCBcunQJGzduRHZ2NoYPH44hQ4YgKiqq2q2qTWnJkiUQQlT5+vDDD5vteETU9FjcIqJasXOLqOOpnNdm/vz5mD9/PlJSUuDg4CB1LKJ2y9zcHElJSXB1dcWYMWPw1ltv8TZF6rBUVVXh7e2NkydPIiEhAWZmZpg7dy769OmDoKAgXLt2TeqIRNQKsbhFRLVi5xZRx1FRUYHIyEjY2dmhuLgYR44cQUhICFRVVaWORtTuaWho4JtvvsGWLVuwdetWDBo0CAcPHpQ6FpGkHB0dER0djezsbHh7e+PTTz+FsbExvL29kZ6eLnU8ImpFWNwiolqxc4uoY8jMzMRzzz2HBQsWYMGCBTh+/Djs7e2ljkXU4cyYMQPp6emwtLTEqFGjMGvWLBQVFUkdi0hSZmZmCAkJwfnz57F+/XqkpKRgwIABcHR0xI4dO/hHWCJicYuIasfOLaL2rby8HKGhobC3t8fDhw9x7NgxhISEQEVFRepoRB2WsbEx5HI5du3ahQMHDsDMzAyBgYG4deuW1NGIJKWpqQkfHx9kZGQgLi4Oenp68PLygqWlJUJDQ3Hjxg2pIxKRRFjcIqJaVRa32LlF1P6kpaVh2LBhCAoKwsqVK5GcnIyBAwdKHYuI/j93d3dkZmZi6dKl+Pzzz2FtbY3w8PBmnVibqC2QyWRwcXGBXC5HTk4Oxo8fjw8//BB9+vSBr68vTp06JXVEImphLG4RUa1kMhmUlJTYuUXUjpSVlSE0NBTPPvssVFVVceLECQQEBChuQyai1kNTUxMrVqzAuXPn4O3tDX9/f1hYWCAyMpJ/eCIC8MwzzyAsLAz5+flYtWoV4uLiYGtrC1dXV8jlcgghpI5IRC2AxS0iqpOSkhI/QBO1E6mpqXBwcEBwcDCCg4ORkJAAa2trqWMRUR309fUREhKCP//8E88//zzeeOMNDBo0CFFRUXj48KHU8Ygkp62tDT8/P5w5cwYxMTEAgIkTJ8LKygphYWG4e/euxAmJqDmxuEVEdVJWVmbnFlEbV1paisDAQAwZMgRaWlpITU1FQECA4tZjImobTExMEBUVhdTUVAwYMADz5s2DmZkZQkNDcfPmTanjEUlOSUkJ7u7uiIuLw59//omxY8di2bJl6NmzJ/z8/JCXlyd1RCJqBvxES0R1YucWUdt2+PBhDBo0COHh4Vi7di0OHjwICwsLqWMR0VOwtbXFli1bcOHCBcybNw+hoaHo1asXfH19kZOTI3U8olahsmsrPz8fwcHBiImJgbm5Odzd3REfH89bFonaERa3iKhO7Nwiapvu3btJ+YjxAAAgAElEQVSHwMBAjBw5EiYmJkhPT4efnx+7tYjaEUNDQwQFBSEvLw8rV67EL7/8AhsbG0ycOBFyuRzl5eVSRySSnK6uLvz8/HD27FnExMSgtLQUrq6uGDx4MCIjI3Hv3j2pIxLRU+KnWyKqEzu3iNqehIQEDBw4EBEREQgPD8e+ffvQu3dvqWMRUTPR1taGv78/zpw5g61bt+Lu3bvw8PBAnz59sGzZMpw5c0bqiESSU1ZWVtyymJycDAcHB/j5+cHExASBgYG4ePGi1BGJqJFY3CKiOrG4RdR23Lp1C35+fnBycoKlpSUyMjLg4+MjdSwiaiGdOnWCl5cX4uPjcf78eSxcuBDbt2+HhYUFhgwZgsjISE6sTQTA3t4eERERyMvLw+LFi7F161aYm5tj2rRpSExMlDoeETUQi1tEVCfelkjUNvz888+KeXjCw8OxZ88eGBkZSR2LiCRibGyMgIAA5ObmIi4uDmZmZnjrrbfQvXt3TJs2DXK5nE9apA7PwMAAAQEBOHv2LLZt24aLFy/C0dFRUQwuLS2VOiIR1QOLW0RUJ3ZuEbVuN2/ehK+vL8aOHYuhQ4ciOzub3VpEpKCkpAQXFxdER0fjwoUL+Pjjj5Gfn4+JEyfC0NAQc+fOxS+//ML5uahDU1FRgaenJ5KSkpCcnIx+/fph/vz5MDU1RWBgIC5fvix1RCKqBYtbRFQndm4RtV579+5F//79sWvXLuzcuRPR0dHo1q2b1LGIqJUyMDDAwoULkZiYiLy8PCxfvhwZGRkYM2YMDA0N4ePjg/j4eJSVlUkdlUgy9vb2iIqKwoULF+Dr64tNmzbBzMwM06ZNw9GjR6WOR0Q1YHGLiOrEzi2i1ufGjRvw9fXF+PHjMXz4cGRmZmLKlClSxyKiNqR3795YvHgxjh49ivPnz+P999/HqVOn4ObmBj09Pbi7uyMyMhKFhYVSRyWSRI8ePRAUFIT8/HxERkYiKysLw4YNw5AhQxAVFcVuR6JWhMUtIqoTO7eIWpcdO3bAysoKcrkcMTExiI6Ohr6+vtSxiKgN6927N/z8/HDo0CGcOXMG//nPf1BaWoq33noLxsbGeOGFF7B69WpkZWVJHZWoxamqqsLb2xtpaWlISEiAmZkZ5syZgz59+iAoKAjXr1+XOiJRh8fiFhHViZ1bRK3DlStXMHXqVHh5eWHMmDHIzMzExIkTpY5FRO2MmZkZ/Pz8EBcXh6KiImzfvh19+vTBf//7X/Tt2xcWFhZYtGgR9u7dizt37kgdl6hFOTo6Ijo6GtnZ2Zg5cybWr18PY2NjeHt7IyMjQ+p4RB0Wi1tEVCd2bhFJb8eOHbCxsUFKSgpiY2MRFRUFPT09qWMRUTunra0NT09PREVFobCwEAkJCZgyZQoOHjwId3d3dO3aFc8//zyCg4ORlJTE27SowzA3N0dISAjOnz+PsLAwJCcnw9bWFo6OjtixYwc/OxO1MBa3iKhO7Nwikk5BQQE8PDzg5eWFKVOmID09HS4uLlLHIqIOSFlZGY6OjggJCUFqaioKCwuxefNmPPPMM9i0aROGDx8OfX19eHh44LPPPuMtjNQhaGlpwcfHBxkZGYiLi4Oenh68vLxgZWWF0NBQ3Lx5U+qIRB0Ci1tEVCd2bhG1PCEEoqKiYGNjg4yMDOzfvx8RERHQ1NSUOhoREQCge/fumD59Ov7v//4PFy5cQG5uLlavXg0VFRWsWLECffv2hYGBAdzd3REaGopDhw7xKYzUbikpKcHFxQVyuRxZWVkYN24cVq1ahd69e8PX15fFXqJmxuIWEdWJnVtELSsvLw9ubm6YPXs2PD09cfLkSTg5OUkdi4ioVmZmZvDx8UF0dDSKiopw5MgRLF26FDKZDKGhoRg5ciS6d++O8ePHIzQ0FIcPH2axi9olS0tLhIWFIT8/H6tWrcIvv/wCGxsbuLq6Qi6XQwghdUSidofFLSKqk7KyMotbRC1ACIHIyEjY2tqioKAASUlJiIiIgIaGhtTRiIgaRFlZGUOHDsWSJUuwe/duXLt2DWlpaVi1ahU0NDQQFhaGESNGQFdXFy+++CKWL1+O3bt348qVK1JHJ2oyOjo68PPzw9mzZxETEwMAmDBhAqytrREWFoa7d+9KnJCo/egkdQAiav2UlJR4WyJRM8vNzcW8efNw6NAhLF68GCtXroSqqqrUsYiImoSSkhJsbW1ha2uLBQsWAABOnz6NhIQEHDp0CDExMQgJCUFFRQVMTEwwbNgwDB06FMOGDcOgQYP472Eb8uDBA6SkpCAtLQ1FRUUs4PyDvb09jI2NkZycjMWLF2PZsmXw9fWFioqK1NGIWpSOjg569uwJOzs7DBgwAEpKT993xeIWEdWJnVtEzaeiogKbNm2Cv78/zM3NceTIEdjb20sdi4io2VlYWMDCwgJz5swBAJSUlODo0aOKr//85z+4du0aVFRUMGjQIAwdOhRDhgzB4MGDYW1tDWVlZYlHQJWEEIiPj0dkZCT27duHu3fvQldXF4aGhuw+roGqqir69++P27dv4/fff5c6DlGLKykpQX5+Pu7fv4/u3btj8uTJeP3112FnZ9fofbK4RUR1YucWUfPIzMzEnDlzcOLECfj7+yM4OJh/vSWiDktHRwdubm5wc3NTLDt9+rSi2FV5q/aDBw+goaGBgQMHYvDgwbC3t8fgwYPRt29fdOrEX29aWmpqKvz8/PD7779j5MiRWLNmDdzc3GBmZiZ1NCJqxR49eoTMzEzs27cPmzdvRkREBF555RWEhobCyMiowfvjv/5EVCd2bhE1rfLycqxduxYffPAB+vbti2PHjmHgwIFSxyIianUqu7teffVVAEBZWRkyMjKQkpKCP/74A0ePHsXGjRtRWloKNTU12NnZwd7eHoMGDcLAgQPRr18/qKmpSTyK9qm0tBSLFy9GREQEHBwccOzYMTz77LNSxyKiNkJZWRkDBgzAgAED8M4772DXrl1YvHgxrK2tsXLlSrz99tuQyWT13h+LW0RUJz4tkajppKWlYc6cOcjMzMTKlSuxZMkS3lpDRFRPnTt3xqBBgzBo0CDFsrKyMpw6dUpR8EpJScH//d//4f79+1BWVoalpSVsbW0xcOBA2NraYsCAAejdu7eEo2j7rl69Cg8PD2RlZeHrr7/GjBkzGvRLKBHRP8lkMnh4eGDMmDFYs2YNAgICkJqaio0bN9Z7zkUWt4ioTrwtkejplZWV4X//+x9WrFiBIUOG4MSJE7C2tpY6FhFRm9e5c2fY2dnBzs5OMX/Xo0ePcObMGaSlpeHkyZNIS0tDZGQk8vLyAAB6enoYMGCAotjVv39/9O3bF7q6uhKOpG3Izs7GmDFj0KlTJyQlJcHKykrqSETUTnTp0gXvvfceHBwcMG3aNJw9exZ79uyp17/NLG4RUZ14WyLR00lNTcXs2bORk5OD4OBgLF26tEmeCkNERDVTVlaGlZUVrKys4OnpqVheUlKCtLQ0pKen4+TJk0hOTsbXX3+NO3fuAACMjY3Rt29f2NjYoF+/for/suj1l6KiIrz00kswMDDA3r17oa+vL3UkImqH3NzccPjwYbi5uWHatGn46aef6pxTkZ+siahO7NwiapzS0lIEBgZiyJAh0NLSQmpqKgICAljYIiKSiI6ODkaOHIk333wTERERSEpKwq1bt3Du3Dns3bsXCxcuhJGRERITE+Hv748RI0ZAT08PxsbGcHNzw9tvv40vvvgCv/76Ky5evAghhNRDajFlZWWYNm0aKioqsHv3bskLW2vWrIFMJoNMJoOxsXGdy9uSrVu3KsYgk8mgqakpdaR249tvv1Wc1y5dukgdp1m1xrEGBgZWubaHDRv2xHX79esHuVyOpKQkvP7663Xum5+uiahO7NwiarjDhw9j0KBBCA8Px9q1a3Hw4EFYWFhIHYuIiB4jk8lgYmKCl156CUuXLsVXX32FY8eO4datW4pbYhYuXIiePXvi0KFDCAwMhIuLC3r37g1NTU0MHDgQnp6eWLZsGb766iscPnwY165dk3pY1TxtIW7ZsmU4ceIE9u7di+7duzdRqsZbsmQJhBCws7Or1/La3LlzBxYWFhg/fnxTx3wq4eHhEEIoOgvp6b388ssQQsDZ2VnqKM2utrFKdc2HhIRACAEhRL3mnB00aBC2bt2Kr776Ctu3b691Xd6WSER1YucWUf3du3cPwcHBWL16Ndzc3BAbG4tevXpJHYuIiBpIJpPB1NQUpqamGDduXJXXbty4gbNnz+Ls2bPIzMzEqVOnEBsbi08//VRRiNDV1YW5uTnMzMwUX/369cOAAQOgra3d4uPZtWsXvvrqKyxfvhwODg4N2vb06dP49NNPsX79evTr16+ZEkpHCIGKigr+MbeVqCwaHzp0SOoo7VZbuuYnTpyIuXPnYunSpXB3d39iJyOLW0RUJ3ZuEdVPQkIC5s6di6KiIoSHh8PHx0fqSERE1Az09PRgb28Pe3v7KnN6VVRU4OLFizh9+jROnz6NnJwc5OTk4Pvvv0deXh7Ky8sBAD169IClpSUsLCxgYWEBS0tLWFpawszMrNluH7pw4QJ2796N3bt348UXX8QHH3yAF154oV7b+vn5oW/fvpg7d26zZJOalpYWcnNzpY5B1GLa2jX/8ccf4/vvv0dISAg+/PDDGtdhcYuI6sTOLaLa3bp1C++//z4+++wzjB07FgcOHICRkZHUsYiIqIUpKSmhT58+6NOnD1xcXKq8Vl5ejgsXLig6viq7vvbv34+8vDzFHxL19PSqdHuZmZmhR48e6NmzJ6ytraGhodGobBcvXoSKigoePnyIhIQEODk5wcHBAe+99x7Gjx8PmUxW43bHjh3Dvn37sH///nrdRkRE1NT09fXx7rvvYuXKlXjnnXdq7H7lnFtEVCd2bhE92c8//wxbW1ts2bIF4eHh2LNnDwtbRERUTadOnWBmZgYXFxf4+PggJCQEcrkcubm5uHPnDk6ePIkff/wRK1aswIgRI1BaWoqffvoJS5YswYQJEzBkyBBoa2ujV69eGDlyJLy9vfHBBx/gq6++woEDB3Du3DlFZ1hNLly4oHi98r8pKSmYMGECbGxsEBUVVeMfMzdt2oQBAwbgxRdfrHOMHh4eVSaLdnR0VLz266+/QiaTQS6XK5YtWrSoyvrl5eUoLy/Hd999B1dXVxgaGkJNTQ22trYICwt7qs+jj0/SLpPJUFhYiJiYmCrLSktLAaDa8ry8PHh5eUFXVxf6+voYP358jZ0vWVlZ8PDwgI6ODtTV1eHg4IA9e/bAxcVFsa958+Y1ehwNPT/Xr1+Hv78/zM3NoaqqCmNjY7i4uODrr7/G/fv3G71uUVERFi5cCBMTE6ioqKBbt26YPHkyUlNTFes8Prn/8ePH4ezsDC0tLairq+PFF19EYmJitfXv3r2LxMRExbaPPyWvPseu9M/3Q0NDAyNHjmyS2x0bOraGZG+Ka6+2sba1a77SvHnzIITAt99+W/MKgohqtG7dOmFoaCh1jFZhwoQJYsaMGVLHoDZqxIgR4q233pI6RpO7ceOG8PHxEQCEp6enuHr1qtSRiIionbp27Zo4fvy42LFjh1i9erWYP3++eOmll0S/fv2EmpqaACAAiE6dOgkTExPh5OQkZs2aJYKCgsTmzZvF77//LgYOHKhY7/EvJSUlIZPJhIWFhdi8ebMoKysTQgjx6NEjYWhoKD766KN6Z92wYYMAILZt21Zl+axZswQA4eXlVWX5jz/+KJydnRXfy+VyAUB89NFHori4WBQVFYn169cLJSUlsWTJkmrHs7OzE0ZGRnUuLy8vF/7+/sLV1VUUFxdXW3/ixIkCgLh//36NyydOnCgOHz4s7ty5I+Li4oSampp49tlnq6x7+vRpoaurK4yMjERsbKy4ffu2yMjIEC4uLqJbt25CVVW1ljP3ty1btggAIjw8vNprDTk/BQUFwtTUVBgaGgq5XC5u3bolCgsLxapVqwQA8cknnzRq3cuXL4s+ffoIAwMDsXfvXsU4X3jhBdGlSxdx+PDhKjns7OyEhoaGeO655xTn8Pjx42LAgAFCRUVFHDx4sMr6GhoaYsSIETWem4Ycu6b3Iy0tTbi5uQkTE5N6vx+1acjYGnrenvbaq2usUl/zysrKYujQofU+10IIMXnyZPHSSy/V9NJlFreInoDFrb9NmjRJTJ8+XeoY1Ea1x+LWnj17hJGRkTAwMBA7d+6UOg4REXVwxcXFIjk5WURHR4uQkBCxcOFC4enpKezt7YWGhoYAINTV1Z9Y3Hq8yGVkZCTWrVsn0tLSBABx9OjReme5fv26UFFREWPGjFEsu3fvntDT0xPPPPOMUFNTE7du3VK8NmnSJLF582bF93K5XDg5OVXb76uvvio6d+4sSkpKqiyvT3Hrxo0bYvTo0cLPz0+Ul5fXmLuuX/TlcnmV5VOnThUARFFRkWKZp6enAFDts8HVq1eFurp6kxW36nt+KguK3333XbX1x4wZU6Vg1ZB1//3vf9dYwCwoKBCqqqrC3t6+ynI7OzsBQJw4caLK8srry87Orsry2opbDTn2k96P/Px8oaqq2mTFrfqOraHnrSmuvdrGKvU135ji1ueffy50dHRERUXF4y+xuEX0JCxu/W3KlCli2rRpUsegNqo9FbeKi4urdGtdu3ZN6khERES1qqioEOfPnxdKSkp1Frcqv2QymQAgdHV1hUwma/DPOw8PD6GsrCwKCgqEEEJs375dUSABIL7++mshxF+FMD09PXH79u0697l69WoBoMauoNqKW1lZWcLS0lKMHTu21v3X9Yt+YWFhleVvv/22ACBOnjypWKalpSUA1DiewYMHN0lx60lqOj86OjoCQJVi4pM0dF0lJaVqhUYh/honAHHx4kXFssruppr07NlTABCXL19WLKutuNWQY9f2ftja2jZp51ZNHh9bQ89bU117Txqr1Nd8Y4pbhw4dqnae/r/LnHOLiOrEObeIgB07dsDKygpyuRwxMTGIjo6Gvr6+1LGIiIhqJZPJGvRZTkVFRTG5/KNHj9CpUyfExcU16Jje3t549OgRvvnmGwDAli1b4O3tjenTp0NZWRnbtm0DAGzfvh3jx4+HpqamYtuSkhKsWLECtra20NPTU8zZs3TpUgDAvXv36p3jxo0b8PDwgLGxMfbt24etW7c2aBz/pKOjU+V7FRUVAFCc1wcPHuD27dvo0qVLlfFU0tPTa/Sx/6m+5+fBgwcoKSlBly5doKWlVes+G7NuRUUFdHR0qs1j9scffwAATp8+XWU7XV3dGvfXvXt3AMDVq1frHHtDjl3X+1F53KZQn7E19rwBT3/tNXasreWa/ycDAwMAf81d9jgWt4ioTnxaInVkV65cwdSpU+Hl5YUxY8YgMzMTEydObPEc3377reIDUHM9Jr4uj0+e+jQen9i3pg9FzelJk6m2JkePHoW7uzt69uwJbW1tDB8+HGFhYSguLm70PqOjoyGTyaCqqtqESdsPqa+LwMDAKscfNmxYix6f2q8LFy7UuPyf/x4oKSnB3Nwcs2bNwldffYWMjAx8+OGH+Ne//oWXX365QccbN24cunbtii1btqCoqAhHjhyBh4cHDAwM4Obmhv3796OgoACbN2+Gt7d3lW3d3d2xatUqvPbaa8jJyUFFRQWEEPjkk08AAEKIeufo1KkT4uPjsWvXLtja2uK1117D8ePHGzSW+lJVVYWWlhZKS0tx586daq/Xp3hTH/U9P6qqqtDR0UFpaSlu375dZ/aGrKurq4tOnTqhrKwMQogavx5/AMH169drfO8qz8s/CzBPenJnQ45d1/vxND9LH1efsTX2vNVHS461Icdtqmv+n9TV1QEAd+/erfYai1tEVCd2blFHtWPHDtjY2CAlJQWxsbGIiopqlr9C1cfLL78MIQScnZ0btf2dO3dgYWGB8ePHNzrDkiVLIISAnZ1do/fxuPDwcAghqnwoaoqsdfHw8IAQQpJCZX0kJibC0dERFRUVSExMREFBAfz8/BAQEIB33nmn0fvt1q1blf/+U0uc99ZO6usiJCRE8QuOsrKyJBmofbp06RKAvz7TVV5bGhoacHZ2xvLly/Hrr7+ipKQEZ86cQUREBLy9vWFjY9OgQtI/qaiowMvLC6mpqVi+fDkmTpwINTU1AMDMmTPx6NEjfPDBBygoKMCoUaMU2z169AiJiYkwNDTEwoUL0a1bN0Wh4/Gn9dWHlpYWjIyMoKmpid27d0NTUxMeHh4oKCho1LjqMnbsWAB/PUn5nwoLC5GTk/PU+2/o+Zk0aRIA4Keffqr22qBBg/D22283at3JkyejvLy8xqcBhoaGonfv3tWe3FlaWlqtsJieno7Lly/Dzs4OPXr0UCxXV1fHw4cPFd9bWVkhMjKywcd+0vtx7do1ZGdnV9u+seo7tsact/pqqbHW97hNdc03BItbRFQndm5RR1NQUAAPDw94eXlhypQpSE9Ph4uLi9SxnooQAhUVFW2iUN2WstZGU1MTjo6Ojdp206ZNKC8vx7p162BqagoNDQ14eXlh7ty5T5WptuJWS573pzk3bV1HHjtJ5+LFizA1NcWMGTPw+eefIyMjA7du3UJcXBzef/99jBo1qsk7aGfOnAkA2LhxY5XuLA8PD2hpaWHjxo2YMWMGlJT+/pVUWVkZTk5OKCwsxOrVq3Ht2jXcv38fBw4cwBdffPFUeUxMTLBz504UFRVh8uTJePDgwVPtryYfffQRunbtikWLFiEuLg537txBRkYGZs+eDUNDw6fef0PPz8cffwxTU1O8/fbb2Lt3L27fvo1Lly7hzTffREFBQZWCVUPXNTc3x5w5c7Bv3z6UlJSguLgYERERCA4Oxpo1a9CpU6cqWXR0dLBs2TIkJSXh7t27SE5OxquvvgoVFRWEhYVVWXfw4MHIycnBxYsXkZSUhLNnz2LkyJENPnZN78epU6fw6quvPvF6f/XVVyGTyXDu3Ll6vy/1HVtjzlt9NWasTaG5r/kGadDsXUQdCCeU/9usWbOe9MhVojq1pQnlKyoqxObNm4Wenp4wNzcXBw4ckDpSNc7Ozk0yAerTeNLkvQ3RmMlym8OTJlNtCrVNiFuXyicq/f77702aqbCwUAAQrq6uTbrfhnqac9MSWsN10ZiJdomepKysrFHbrVu3TvTo0aPRx7WwsBC9e/eu9mSzyifzZWZmVtumqKhI+Pr6il69eonOnTsLAwMDMWvWLBEYGKiY8N7e3l4xgfo/v5YvXy62b99ebfknn3wikpKSqi2fMWOG+PHHH2tcXtP6y5cvF0KIasvHjRunyJ+dnS08PDyEtra2UFdXF8OHDxe//fabcHJyEurq6vU6b7X9jKzv+al07do1sWjRImFqaio6d+4sevToIV5++WWRk5NTbd8NWff69evC399fmJmZic6dO4tu3boJNzc3ERcXV23dys8Np06dEqNHjxZaWlpCTU1NvPDCC+LQoUPV1s/KyhIjR44UGhoaolevXmLDhg2NPvY/3w81NTXx7LPPij179ghnZ2fF+Zo7d65i/VGjRglNTc0nPlXzacdWn+xNce3VNtbWcs035udcfn6+ACASEhIef4lPSyR6Eha3/jZnzpwqj3Mmaoi2Utw6d+6ccHFxEUpKSsLHx0fcuXNH6kg1YnGrabWGIkZNdu3apXiEeH2eIlZf5eXlQiaTiVdeeaXJ9tkYLG6xuEVtw9MWt+hvVlZWonfv3vVat7X8jGwqTfG5oSXcuHFDqKmpiXnz5tV7m7YyNinUdc03dXGLtyUSUZ14WyK1Z0IIREZGwtbWFgUFBUhKSkJERAQ0NDQkzZWVlQUPDw/o6OhAQ0MDI0eOxKFDh6qt9/gE2NnZ2Zg2bRr09fUVyzZt2lTjJNmPb5uXlwcvLy/o6upCX18f48ePR25ubp1ZH58cXiaTobCwsFHjrm1C7wcPHmDFihWwtraGuro6unbtCnd3d+zevfup/40qLCys19ivX78Of39/mJubQ0VFBXp6ehg7diwOHDigWKdy4v27d+8iMTFRMZaG3Gpgbm4ObW1tnDx5EhMmTGiyic2VlZWhp6dX7bbEljrv9T039TnPjVm3oVrbdUFErVthYSG6du2KsrKyKsvz8vKQm5tbZX4xal2EEFi4cCG0tbWxatUqqeO0Ga3qmm9o9Y2oo2Dn1t98fX2Fs7Oz1DGojWrNnVtnzpwRTk5OolOnTiIgIECUlpZKHUkIIcTp06eFrq6uMDIyErGxseL27dsiLS1NuLm5CRMTkxo7tyo7TV544QVx4MABcffuXXHkyBGhrKwsioqKqqzzeDdK5fKJEyeKw4cPizt37oi4uDhFS/vjHv8rZXl5ufD39xeurq6iuLi4XmOs66/SNWWdN2+e0NHREbGxseLevXuisLBQLFmyRABo9C2kNY39119/Fdra2tXGXlBQIExNTYWBgYGQy+WipKREZGdni8mTJwuZTCY2btxYZf3Gdift379fqKuri3Xr1inyjR8/vsptRePGjatye8CUKVPqvX8rKyvx4Ycf1vhaS5332s5NQ85zQ9+T+moN1wU7t6g1YOdWwxQUFAgAYvbs2eLChQvi7t274ujRo8LBwUF07dpV5Obm1ms/lT8jK780NDSaOXnzagvdTQUFBWLEiBEiIyOjQdu1hbE1p4Ze8wEBAVWubd6WSNQCWNz62xtvvCGcnJykjkFtVGssbj169EhEREQIDQ0NMWDAAJGcnCx1pCo8PT0FALFz584qy/Pz84Wqqmqtxa2ffvrpifutq7gll8urLJ86daoAoCiOVfrnB7kbN26I0aNHCz8/v3rPTyFE44pbpqamYvjw4dXWtbS0fOri1uNjf+WVV6qNvXKOmO3bt1dZt7S0VPTs2VOoqamJwsJCxfLGFLeKioqEjo6OGD16tGLfo0aNEgDEyy+/LB49eqRY9+zZs2y23LEAACAASURBVEJNTa1B512Iv/6flPq813ZuGnKeG/qe1FdruC5Y3KLWgMWthouPjxeTJk0SJiYmQkVFRRgYGIgZM2aIM2fOSB2txT1pXrT2oD2PraFa8prnbYlE9FSUlZXb/FPLiCplZmbiueeew4IFC7BgwQIcP34c9vb2UseqovJxyqNHj66yvGfPnrC0tKx1WwcHh0Yf99lnn63yfa9evQAAly9frnH97OxsDB06FEpKSli3bp3i8fLNZcyYMTh8+DB8fHxw5MgRxS1x2dnZcHJyeqp9Pz52IyMjAFXH/uOPP+L/sXfncVFX+//AX8M27JsrogmDCoqluSuQ3gDNxCSM9IbcFhW1MgktqW7uFZYLePOSS7dfN8tCb2645F6upSaaKIOC5gKYxi4wgpzfH35nYpwBZoDhA/h6Ph7zuM5nPvM573M+n5vw9pz3AYBRo0ZpnSuXyxEYGIjS0lL88MMP9Yrjiy++QEFBASIiIjTX3rJlCwYMGIBvv/0WU6dO1Zx78OBB+Pv7Gz3uFhYWRi2FM+W462PMOJv6njSV54KImo/AwEB8//33uHz5MlQqFXJycrBu3Tp4eXlJHVqjmzVrFoQQWq9FixZJHVaDaMl9M1ZTeeaZ3CKiWrHmFrUEFRUVWLx4Mfr27Yu7d+/il19+QVxcHKysrKQOTYtKpUJRURGsra31bt3ctm3bGr9fn1phTk5OWu/VY6MvuZ2Xl4fQ0FB07NgRO3fuxLp16+rcrqFWrlyJ//73v8jMzERgYCAcHR3x1FNPaZIL9fFg39Vb06v7rlKpUFBQAGtrazg4OOh8v127dgBQ51pjaunp6VrXAwB7e3vs3LkTPXv2xJo1azBz5kzcu3cPCQkJmDRpUr3aM4Qpx/1BxoxzY9yTpvJcEBERUc2Y3CKiWnHmFjV3Z8+exaBBgzBv3jzMnz8fJ0+eRO/evaUOSy+5XA4HBweUlZWhuLhY5/Pc3FwJotJlYWGBvXv3YsuWLXj00UcxefJknDhxwqRtymQyREZGYu/evcjPz8fmzZshhEBYWBiWLVtm0rblcjmcnJxQVlaGoqIinc9v3rwJAGjfvr1WvMZq1aoVAODChQtax11dXbF7924oFAosW7YMgwcPhp2dHcLDw41u4+DBg0YlxUwx7tWNjTHjXJd70tAa67kgIpLC77//jmeeeQaFhYWaY/7+/jqbyKhf0dHRdWonNjYW3333XUOFLRl94/Wgb7/9VjNe1tbWjRhdzVrCPWByi4hqxZlb1FyVl5dj8eLF6N+/P+RyOU6fPo3Zs2ebfPlcfY0cORLAX8sT1W7fvg2lUilFSDocHBzg7u4Oe3t7bN26Ffb29ggNDUV2drbJ2nR2dkZaWhoAwNLSEsHBwZpd/rZv326ydtWeffZZANBpS6VSYd++fbCxsdFaSmpra4u7d+9q3nt7e2P16tUGtbF8+XLk5eVpfebm5oa9e/fC2dkZJ06cQFBQUKMkSkwx7jWNjTHjbOw9MYXGeC6IyPSKi4vRtWtXhISESB1Kk5CSkoJ+/fph+PDhcHR0NGlbkydPxjvvvIP333/fpO2YkqHjNX78eAghEBgY2IjR1a4l3AMmt4ioVpy5Rc1RSkoKBgwYgAULFmDBggU4dOgQfHx8pA7LIB9++CFcXV0RHR2NPXv2oLi4GOfPn8eECRP0LlWUmoeHBzZu3Ihbt24hLCwMKpXKZG1NnToVZ8+ehUqlwh9//IGPP/4YQohG2Wr6o48+gqenJ6Kjo5GcnIyioiKkp6fjhRdeQHZ2NhISErSWE/bp0wfp6em4du0ajh07hszMTAQEBNTYxsCBAxEbG4vff/8d/v7+2LFjB+7cuYOSkhIcOXIEb7/9Nuzs7ODi4oKFCxfiyy+/NKoPp06dQuvWreHv72/Uf9cbetxrGhtjxtnYe2IKjfFcEFHDsLe3h7+/v97PhBCorKx8KH7mrWkcAKCwsBCjR4/G2LFj8frrr+t8fuLECZ16U0IIxMfH1ykeLy8vbNq0CR988AGSkpLqdA0p1TZezUFzvwcAwN0SiarB3RL/EhsbKx5//HGpw6BmqrF3SywtLRWzZ88W5ubmIiAgQKSnpzda2w1JqVSK0NBQ4ejoKGxsbET//v1FcnKyCAwM1OzKM3HiRHHs2DGd3Xoe/Ot906ZNOp9HRETo/a56p58Hj48aNUqsX79e5/jy5cv1XiciIqLG/lW3W2J1sQohREpKipgyZYro3r27sLW1Fa6urmLQoEFizZo1orKy0qjxNbbvardv3xbR0dHC09NTWFpaanY23Ldvn04baWlpIiAgQNjZ2YlOnTqJlStXGhxfcnKyePrpp0Xr1q2FhYWFcHZ2Fn5+fmLp0qWiqKhIHD16VNja2mrFWV5eXut1T5w4oRm3qjsvNta4q9U2NsaMszHn1qYpPRfcLZGagpa2W2JddrFtiWobh/fee09YWFiIGzdu6Hzm5+cnTpw4YZK4wsPDRceOHQ36+6wuevfuLeLi4sTvv//eoNetabyqExgYqHf3a6mZ+h7UV027JTK5RVQNJrf+8t5774levXpJHQY1U42Z3Dpy5Ijw8fERjo6OIj4+XuuXd2paqktuEdF9TG5RU8DkVstU0zhUVlaKdu3aVfu5KZNb33zzjQAgNm/ebJLrjxw5UpibmwuZTCaGDh0qVq9eLfLy8up1zdrGqzpNNbll6ntQXzUlt7gskYhqxZpb1NSVlJQgNjYWAQEB8PDwwLlz5zBjxgzNzmZERET08FqyZAlkMhnu3LmDI0eOaAp6W1hYAICmjqD6VVZWpvf477//jnHjxsHBwQGtWrVCZGQk8vLycOXKFYwePRoODg5wc3PD5MmT9W4ycevWLbzxxhvw8PCAlZUV2rRpg7CwMKSkpOic++effyImJgZeXl6wsrKCi4sLRo4ciQMHDmjOWbRokSa2qssMd+3apTneunVrg8cBAM6cOYObN2+iV69e1Y7nV199hd69e8POzg5OTk4ICAjAN998o3OeSqXCnDlz4OPjA1tbW7i6umL06NHYunWr3t8t1Jv9/PDDD9W2XR87duzA9evXsWTJEhQWFiIqKgrt27dHWFgYvv/++zqVVahtvNLS0hAaGgonJyfY2dkhICAAhw8frvZ6htx3Yzg7O1e7AYCZmRmuX7+udb6p74Ep8ad+IqqVmZnZQ1F/gJqnQ4cOoXfv3li1ahUSExOxc+dOdOrUSeqwyEDTpk2DTCZrkrXEiBpbbGys5pcO/qMSUcOZNWsWhBCws7ODn5+fpkZURUUFACA0NBRCCIwZM0brew8ej4mJwdtvv42cnBzEx8dj3bp1iIiIQHR0NBYuXIjs7GzMmzcPa9euxdy5c7WulZ2djf79+yMpKQn//ve/kZubi4MHDyI3NxeDBw/GsWPHNOfm5OSgf//++Oabb5CQkIDbt2/j559/hq2tLQIDA7F27VoAwD//+U9Nv6p66qmnIIRA3759jRoHADh37hwAoGPHjtWOZ15eHv7zn//gjz/+wC+//AJPT09ERETgjTfe0Drv9ddfx4oVK/Cvf/0Lf/75Jy5cuAAfHx+MGTMGhw4d0rmuu7u7Vgym0L59e8TExODXX3/F+fPnERMTg1OnTmHs2LFo3749Jk+ejIMHD0IIYdD1ahqvS5cuYfDgwTh58iQ2btyImzdv4t///jcWLlyIjIwMnfMNve/GKioq0qqNtmDBAgDABx98oBN3Y9wDk2mcyWNEzQ+XJf5lwYIFwtvbW+owqJky1bLEgoIC8cYbbwgzMzMxatQocf369QZvg5of6Kk/9uBr7ty5UofZ4jT1cW/q8RE1VQ/bssQxY8YIAKK0tFTv8e3bt2sd9/X1FQDEjz/+qHXc09NT52fnF198UQAQX3/9tdbx7OxsIZfLRd++fTXHXnrpJQFArF+/XuvcsrIy0aFDB2FjYyNycnJq7Vffvn1Fq1atdI7XNA4ff/yxAGBUnUghhBgwYIAAII4fP6455unpKYYMGaJzbrdu3cSBAwf0Xkcmk4kuXboY1XZ9VVZWioMHD4pJkyYJZ2dnAUA89thjBn23pvEKDw8XAMTGjRu1jt+4cUPI5XKdZYnG3ndDODk5iaKiIs377777TshkMvHSSy9V+x0p7oGhuCyRiOqFM7eoqdm1axceffRRfPXVV0hMTERycrLmX5ro4Sb07N704GvevHlSh9niNPVxb+rxETVVMplM6hD0OnfunM4Sq8bYpa5fv35a7zt06KD3uLu7O7KysrSObd68GWZmZggJCdE63r59e/j6+uLUqVOaJWKbNm0CAIwaNUrrXLlcjsDAQJSWlpps2Zh6SaalpaVR33vuuecAANu2bdMce+qpp3D06FFERUXh+PHjmhmpSqUSw4YN03sdCwsLlJaW1iHyuj8XMpkM1tbWsLa2NrrfNY3Xrl27AAAjRozQOt6hQwd069ZN53xT3Pf8/HzN7Piff/4ZL774Ip544gmsWrWq2u/U5x40Fn3/bbLQcx4RkRZzc3Muj6AmIT8/H7Nnz8bq1asRHh6OlStXok2bNlKHRURE1CLZ2tqipKRE6jB09OzZ0+BlYw3J0dFR672ZmRnMzc1ha2urddzc3FzrH4ZVKhUKCgoAAE5OTtVe/+LFi2jTpg0KCgpgbW0NBwcHnXPatWsH4P4SNlOwtrYGAJSXlxv1PTc3NwDAH3/8oTm2cuVKDB48GF9++SUCAwMBAAEBAZgyZQqeffZZvdepqKiAjY1NXUI3+rlIT0/H119/ja+//hoZGRlwdnbG2LFjERERUW3y7UHVjZdKpUJRURGsra31ll5o27Yt0tPTtc435X2/evUqxowZg06dOuH777+HlZVVtefW5x6YWnFxMQDoHVPO3CKiWnHmFjUF27dvR8+ePbFlyxZs3LgRSUlJTGwRERGZUNu2bVFYWIg7d+5IHUqDkGommlwuh7OzMywsLFBeXl7tDNK//e1vkMvlcHJyQllZmd6i9Ddv3gRwf8aXmpmZGe7evatzbn5+vt54ahoHdZJKnYwzlHqmWtu2bbXaiYyMxN69e5Gfn4/NmzdDCIGwsDAsW7ZM5xqFhYUQQmhiMIWbN29ixYoVGDBgALy9vREXF4dHH30UGzduRE5ODtauXYu//e1vBj8r1Y2XXC6Hg4MDysrKNAmZqnJzc3XON/a+G6qoqAghISEoLy9HcnIyXF1dqz23Me5BfajHQd/vAExuEVGtmNwiKeXl5WHKlCkICQnBkCFDkJqairFjx0odFhERUYunnglz5swZqUNpELa2tlpJIG9vb6xevbpR2g4LC0NFRQWOHDmi89nixYvxyCOPaAq7q2c1bd++Xes8lUqFffv2wcbGRmupm5ubG27cuKF1bk5ODq5evao3lprGoWfPngCgs4seAKxdu1anSD1wf+l3UlISAGD06NGa487OzkhLSwNwf9lecHCwZgfKB/sGQNMHdQwNbdSoUXB3d0d0dDRsbGywatUq5OTkYNOmTRg7dizkcrnR16xpvEaOHAngr+WJardv34ZSqdQ539j7boh79+5h/PjxSEtLw//+9z+t5ZDPPfccNm/erHW+qe9BfaWkpMDFxUWzJLgqJreIqFZclkhS2bBhA7y9vbFt2zZs3rwZSUlJaNWqldRhERERPRQUCgU6d+6MPXv2SB1Kg+jTpw/S09Nx7do1HDt2DJmZmQgICGiUtj/66CN4eXnhlVdewc6dO1FQUIDc3FysWrUKCxYswJIlS2BhYaE519PTE9HR0UhOTkZRURHS09PxwgsvIDs7GwkJCZplagAwfPhwZGVl4dNPP0VxcTEyMjIwY8YMrVlUho5Dr1690LZt22oTmr/++itee+01XLp0CWVlZVAqlYiMjMSpU6cwffp0DBw4UOv8qVOn4uzZs1CpVPjjjz/w8ccfQwiBJ598UufaKSkpmv6YQlZWFhYtWoQrV67gxx9/RFRUFFxcXOp1zZrG68MPP4Srqyuio6OxZ88eFBcX4/z585gwYYLeZXXG3ndDvPnmm9ixYwdWr15t0FJLU9+D+tq9ezeGDh2q/8MGLFxP1KJwt8S/tLSdcqhx1WW3xJycHDF27Fghk8lEZGSkyM3NNVF0REREVJPXXntN+Pj4iMrKSqlDqbe0tDQREBAg7OzsRKdOnTQ73G3atElnB9WIiAhx7NgxnePvvfeeOHHihM7xjz76SBw6dKjGnVj//PNPERMTIxQKhbC0tBRt2rQRw4cPF3v27NGJ9fbt2yI6Olp4enoKS0tL4eTkJEaMGCH27dunc25+fr6YNGmScHNzEzY2NsLf31+cOHFC9O3bVxPH7Nmzax0HtXfffVdYWFiIGzduaB0vKysTGzZsEM8++6zw8vIScrlcODk5iWHDholvvvlGJ66UlBQxZcoU0b17d2FraytcXV3FoEGDxJo1a/Q+T+Hh4cLd3V3cvXu35hvZxFQ3XkIIoVQqRWhoqHB0dBQ2Njaif//+Ijk5WQQGBmruzcSJEzXnG3Pfa3Py5MladwretGmT1nea8j24deuWkMvl4osvvtD3cZZMCAkq8RE1AwkJCYiLi0N2drbUoUju008/xcKFCzVrnImM4e/vjz59+mDFihUGnb9hwwZMmzYNDg4OWLNmDYKCgkwcIREREVXnzJkz6N27N7Zv346nn35a6nCoERQUFMDX1xchISH47LPPGqXNM2fO4PHHH8c333yD8ePHN0qbDUWK8TKFpn4PFi5ciKVLl+LGjRuws7N78ONsLkskolqx5hY1huzsbISGhmLcuHEYO3YsfvvtNya2iIiIJNarVy+EhYVh1qxZRu+gR82Tk5MTtm3bho0bN2LlypUmby8zMxNhYWF45513mmRSpTaNPV6m0NTvwY0bN/Dxxx/j7bff1pfYAsCaW0RkANbcIlMSQuC///0vfH19ce7cOezfvx+rVq3SW4uAiIiIGt/y5cvx+++/49NPP5U6FGokjz/+OE6ePImdO3eisLDQpG2tWrUKH3zwAT744AOTtmNKjTleptDU78Hbb7+Ntm3bIiYmptpzLBoxHiJqpjhzi0zlypUrmDx5Mvbv349JkyZh2bJl1f5rDBEREUnjkUcewaxZs/DPf/4TTzzxhN4d86jl8fDwQHJyssnbWbx4scnbaAyNNV4ymazWc+bOnYt58+YZfM2mfA/WrVuH9evXY/PmzbC2tq72PCa3iKhWnLlFDU0IgTVr1mDmzJno3Lkzjh07hgEDBkgdFhEREVVjzpw5+PXXXzF69Gj8/PPP6NSpk9QhET2UHqay6UeOHMGkSZPw9ttv45lnnqnxXC5LJKJaceYWNaSMjAw8+eSTeO211/Daa6/h1KlTTGwRERE1cebm5li3bh1cXFwwatQo3LhxQ+qQiKgFO3HiBEJDQzFy5Eh8+OGHtZ7P5BYR1Yozt6ghVFZWYvXq1ejVqxdyc3Nx/PhxxMXFQS6XSx0aERERGcDJyQk7duzAvXv3MHDgQPz6669Sh0RELdDGjRsxbNgw9O/fH+vWrYOZWe2pKya3iKhWnLlF9ZWbm4vBgwfj9ddfx+uvv44TJ06wXgcREVEz1LlzZxw9ehS+vr544okn8K9//QsVFRVSh0VELUBhYSFmzpyJ559/HhMnTsS2bdsMrsfL5BYR1Yozt6iuKioqcP36dXz77be4e/cufvnlF8TFxcHKykrq0IiIiOgBlZWVuHz5Mnbt2oXly5cjOjpa73lOTk7Yvn07oqOj8dZbb6F3797YvXt3I0dLRC1FRUUFvvjiC3h7e+PLL7/E559/jhUrVsDc3Nzga7CgPBHVijO3qC7Onj2LV155BdeuXcOgQYPw008/GfUXFBEREZlGaWkplEollEolLly4gLS0NM370tJSAEDbtm3RvXt3lJaWwsbGRucaFhYWWLRoEV5++WXExMRgxIgR6NmzJ1544QUEBwfjscce4z9mEVG1CgsLcfr0aezYsQNff/01bt68ialTp2L+/PlwdXU1+npMbhFRrdQJicrKSoPWO9PDrby8HMuWLcOcOXPQr18/9O7dG3379mVii4iIqJHl5eUhMzMTqampOH/+vObPSqUS9+7dg4WFBR555BEoFAo88cQTmDZtGhQKBXr27In27dsb1IaXlxe2bNmCkydPYs2aNUhISMC7774LCwsLuLq6wt7e3sS9JKLmJj8/H3l5eRBCoGvXrnjxxRcxadIkeHp61vmaTG4RUa3UCa179+4xuUU1SklJwcsvv4z09HQsWLAAb731Fp544gmpwyIiImqxKioqcPXqVZ0k1m+//YabN28CAORyOby8vODr64vRo0dj9uzZ8PX1RY8ePfTOyqqLfv36oV+/fkhMTIRSqcRvv/2GW7duobi4uEGuT0Qth5OTEzp06IBevXqhc+fODXJNJreIqFZVZ24R6VNWVoZ58+ZhyZIlGDJkCFJSUtC1a1epwyIiImoxVCoVLl26hPPnz2slsc6fP69ZSuji4oIePXrA19cXQUFBmj97enpCJpM1SpxmZmbo3r07unfv3ijtEREBTG4RkQGqztwietDRo0cxceJEZGVlYenSpZg+fTpn+BEREdVRXl6ezjLC8+fP4/LlyxBCwNLSEp06dUKPHj0QFBSEqKgo9OjRA7169YKDg4PU4RMRSYLJLSKqlTpRwZlbVFVJSQkWLFiATz75BMOHD8fu3bvRqVMnqcMiIiJq8srLy3Ht2jWdJNbZs2dRVFQE4P4sLIVCAYVCgcjISM0yQh8fH9axJCJ6AJNbRFQrLkukBx06dAgTJ07ErVu3kJiYiKioKKlDIiIianJqK+gOAG5ubvD19YWvry/Cw8Ph6+urSWoREZFhmNwiolpxWSKpFRYW4v3338enn36KkSNH4sCBA3B3d5c6LCIiIkllZWXpLCPMzMxEZmYmAMDKygpdunTRKeju4+MDOzs7iaMnImr+mNwiolpx5hYBwK5duxAVFYXi4mLO1iIioofO3bt3cfHiRZ0kVlpaGu7cuQPgr6WE6npY6oLuHh4erEdJRGRCTG4RUa04c+vhlp+fj9mzZ2P16tUIDw/HypUr0aZNG6nDIiIiMonqCrpfuXIFlZWVsLCwwCOPPAKFQgE/Pz9ERUVBoVDgscceQ9u2baUOn4joocTkFhHVijO3Hl7bt2/HlClTUFFRgY0bN2Ls2LFSh0RERFRvFRUVuHr1qs4ywrNnz+KPP/4AADg5OaFLly5aBd0VCgV8fX1hbW0tcQ+IiKgqJreIqFacufXwycvLQ2xsrGa2VmJiIlq1aiV1WEREREYpKCjApUuX9BZ1LysrA3B/KaF6+WBISIgmieXp6QmZTCZxD4iIyBBMbhFRrThz6+GyYcMGvPbaa7CwsMDmzZsxZswYqUMiIiKqUXUF3S9fvgwhBKysrNCxY0dNLayoqCj06NEDvXv3hr29vdThExFRPTG5RUS14syth8PNmzfx2muv4fvvv8eECROQkJAAFxcXqcMiIiICcL+g+/Xr13VmYJ05cwbFxcUAdAu6q//s4+Oj+cc6IiJqeZjcIqJaceZWy7dhwwZMmzYNDg4O2L17N4KCgqQOiYiIHlJ5eXl6lxEqlUrNP7S5ubnB19cXffv2xT/+8Q9NLSw3NzeJoyciIikwuUVEteLMrZYrOzsb06ZNw9atWzF58mQsXbqUyzOIiMjkqivofu7cOeTk5AAA5HI5vLy84Ovri9GjR2P27Nnw9fVF9+7dYWtrK3EPiIioKWFyi4hqxZlbLY8QAl999RWio6Ph6uqK/fv3Y9iwYVKHRURELYxKpcKlS5d06mFduHABJSUlALQLugcFBWn+7OHhofkHNiIiopowuUVEteLMrZblypUrmDx5Mvbv349JkyZh2bJlsLOzkzosIiJqxvLy8nSWEZ4/fx5XrlxBZWUlLC0t0alTJ52C7o899hgcHR2lDp+IiJo5JreIqFacudUyCCGwZs0azJw5E507d8axY8cwYMAAqcMiIqJmory8HNeuXdNJYv32228oLCwEADg7O8PLywsKhQKRkZHw9fWFQqFAz549IZfLJe4BERG1VExuEVGtOHOr+cvIyMCkSZNw+PBhzJw5E/Pnz+cvGUREpFd+fj4yMjK0ZmClpqYiPT0dFRUVAP4q6O7r64vw8HBNEkuhUEgcPRERPYyY3CKiWnHmVvNVWVmJtWvXIiYmBl5eXjh+/Dj69u0rdVhERNQEZGVl6SwjzMzMRGZmJgDAysoKXbp00RR0V9fC8vHx4XJ2IiJqUpjcIqJaceZW85SamopXXnkFp0+fRkxMDBYsWAArKyupwyIiokZ0584dpKenIy0tTfNSKpVQKpUoKysDALRv3x4+Pj7w8fFBSEgIfHx84O3tjc6dO0Mmk0ncAyIiotoxuUVEtVIntzhzq3moqKjA0qVLMXfuXHTv3h2//PILevfuLXVYRERkQrUVdLewsMAjjzwChUKBoUOH4tVXX4VCocCjjz6Kdu3aSR0+ERFRvTC5RUS14rLE5uPs2bN45ZVXkJqaivnz52PWrFma+0dERM1bcXEx0tPToVQqNTOw1O9LSkoAAK6urvD29kb37t3h7++Pbt26oXv37vDy8oKlpaXEPSAiIjINJreIqFZcltj0lZeXY9myZZgzZw769euH06dPw8fHR+qwiIioDqrWwqptFlZAQACmTp2qKebOgu5ERPQwYnKLiGrFmVtNW0pKCl5++WWkp6djwYIFeOuttzQJSSIiappUKhUuXbqks4xQqVSiuLgYAODi4qJJWEVGRmp2JOzRowdsbGwk7gEREVHTweQWEdWKM7eaprKyMsybNw9LlizBkCFDkJKSgq5du0odFhERVVHdjoSXL1+GEAKWlpbo1KkTFAoF/Pz8EBUVBYVCAV9fX7i5uUkdPhERUbPAf9onolpx5lbTc/ToUTz++ONITEzE0qVLcfDgQSa2iIgkUlBQQvtA4wAAIABJREFUgFOnTmHDhg1YvHgx/vGPf6Bfv36wt7eHu7s7goODERsbiyNHjsDNzQ1RUVH47rvvcPLkSRQWFuKDDz7A3r17sWLFCrzxxhsICgpq9MTWkiVLIJPJIJPJ0LFjx3pda926dZpryWQy2NvbN1CUhtm8ebNW++pdIZuSn3/+GaNHj0aHDh3g6OiIIUOGICEhAbm5uXW+ZlJSEmQyGeRyeQNG2nJI/VzExsZqtT9o0KBGbZ+opWNyi4hqxZlbTUdJSQliY2MREBAADw8PnDt3DjNmzOAyRCKiRpCVlYW9e/di9erVmDFjBoKDg+Hl5QUXFxf069cPERERWL16NbKzs+Hn54dly5Zhz549yM7ORm5uLk6ePIn//ve/mD17NsLDw9G3b19YW1tj/PjxEEIgMDCwTnEVFxeja9euCAkJqXPfZs2aBSEEevXqVedrPCgxMRFCCM0yS6BhYq1NaGgohBAYM2aMydqojyNHjsDf3x+VlZU4cuQIsrOzMWPGDMyePRtvv/12na/bpk0brf+tqjHGvamT+rmIi4uDEAJCCG72Q2QCXJZIRLXizK2m4dChQ5g4cSJu3bqFxMREREVFSR0SEVGLU1BQgEuXLukUc79w4YJmR0J1LawePXogKChI82dvb29YWDT+j9dCCFRWVjaLv6ebU6w1sbe3R+/evXH48GGjv7t27VpUVFQgPj4enp6eAIBx48bhp59+gkqlqnNMNSW3GnPc6zM2zd3D3HciqTG5RUS14swtaRUWFuL999/Hp59+ipEjR+LAgQNwd3eXOiwiombN0FpY6gSWuhbWo48+inbt2kkdvhYHBwdkZGRIHYZBmlOspiKEAADk5ORolRRYuXJlva5bU3KL405ELR2TW0RUK87cks6uXbsQFRWF4uJiztYiIjJSfn4+MjIydBJYhszC8vHx4dIhMomwsDB8+eWXmD59Og4fPtxgNclat24NmUymN7lFRNTSsUgLEdWKM7caX35+PqZMmYKRI0di0KBBUCqVTGwREelRUVGBzMzMGmthTZgwAV999RVKS0sRFBSE5cuX49ChQ8jPz9dbC8vX19ekia20tDSEhobCyckJdnZ2CAgI0LuM6cEC2EqlEs8//zxatWqlObZ27Vq9RbIf/O6VK1cwbtw4ODs7o1WrVggJCTFoJs+DxeFlMhlycnLq1O+aCnqrVCrMmTMHPj4+sLW1haurK0aPHo2tW7fW++ePnJwcg/r+559/IiYmBl5eXrCysoKLi4tmxrSauvD+nTt3cOTIEU1fjFmO6uXlBUdHR5w5cwbPPPNMgxU2Nzc3h4uLi05yq7HG3dCxMWSc63KusZrac0FE9SSISK/4+HjRvn17qcNoEsrLywUA8f3330sdykMhOTlZuLu7i3bt2on//e9/UodTb35+fmL69OlSh0FEzdytW7fEkSNHxOeffy5mz54tQkNDhY+Pj7C0tBQABADh7u4unnzySTF16lQRHx8vdu7cKTIzM8W9e/ekDl/j4sWLwtnZWbi7u4vdu3eLoqIicfbsWTF8+HDh4eEh5HK5znfGjBkjAIihQ4eKAwcOiDt37ojjx48Lc3NzcevWLa1zSktL9X53zJgx4ujRo6K4uFjs2bNH2NjYiP79++u01atXL+Hu7q55X1FRIWJiYkRwcLDIzc01qI9fffWVACASExP1fq4v1kmTJgknJyexe/duUVJSInJycsSsWbMEAHHgwAGD2q2unap937dvn3B0dNTpe3Z2tvD09BTt2rUT27ZtEwUFBUKpVIqwsDAhk8nEmjVrtM63s7MTfn5+Rse0f/9+YWtrK+Lj4zXxhYSEiPLycs05o0aN0jzTAMTYsWMNvr63t7dYtGiR3s8aa9xrGhtjxtnYe2KopvBcmJubi4EDB9YpfiLSK4vJLaJqMLn1l3v37gkAYsOGDVKH0qLl5uaKqKgoAUCEh4eL27dvSx1Sg2Byi4gMpVKpREZGhti6dauIi4sTUVFRIigoSLi5uWl+0beyshIKhUKEhISI2bNni1WrVolDhw6JgoICqcM3SHh4uAAgNm7cqHX8xo0bQi6X15jc2rFjR7XXrS25tW3bNq3jzz33nACgSY6pVU1u5eXliREjRogZM2aIiooKg/tYl+SWp6enGDJkiM653bp1q3dy68G+v/DCCzp9f+mllwQAsX79eq1zy8rKRIcOHYSNjY3IycnRHK9LcuvWrVvCyclJjBgxQnPtJ598UgAQ48eP10rCZmZmChsbG6PGXYj7f+dKPe41jY0x42zsPTFUU3gumNwianBZXJZIRLUyMzODTCZjzS0T2rBhA7y9vbFt2zZs3rwZSUlJaNWqldRhERGZRFZWlmYZYWxsLEaPHg0vLy/Y2trCy8sLzzzzDBISEpCZmQmFQoEZM2Zg69atyMjIQElJCTIyMrBt2zbExcUhKioK/v7+cHR0lLpbBtm1axcAYMSIEVrHO3TogG7dutX43QEDBtS53f79+2u979SpE4D790IfpVKJgQMHwszMDPHx8SavP/bUU0/h6NGjiIqKwvHjxzVL4pRKJYYNG1avaz/Yd/WmLFX7vmnTJgDAqFGjtM6Vy+UIDAxEaWkpfvjhh3rF8cUXX6CgoAARERGaa2/ZsgUDBgzAt99+i6lTp2rOPXjwIPz9/Y0edwsLC6OWwply3PUxZpxNfU+aynNBRA2Di4CJyCBmZmasuWUCN2/exGuvvYbvv/8eEyZMQEJCAlxcXKQOi4io3vLy8pCZmalTzD0tLQ137twB8Fcxd4VCgcjISPj6+kKhUMDHxwd2dnYS96DhqVQqFBUVwdraWm8R8bZt2yI9Pb3a79dnTJycnLTeW1lZAdC/WUxeXh5CQ0PRsWNH7Ny5E+vWrcOECRPq3LYhVq5cicGDB+PLL79EYGAgACAgIABTpkzBs88+W69rP9h3dS1Rdd9VKhUKCgpgbW0NBwcHne+rd8esa60xNfW9rbrbpr29PXbu3ImhQ4dizZo1cHBwwMcff4yEhAS8++679WrPEKYc9wcZM86NcU+aynNBRA2DyS0iMoiZmRlnbjWwDRs2YNq0aXBwcMDu3bsRFBQkdUhEREa5e/curl+/rpPASk1NRXZ2NoD7SZSOHTtqdiOMioqCQqGAr68v3NzcJO5B45LL5XBwcEBRURGKi4t1Ely5ubkSRabNwsICe/fuhZOTE4YMGYLJkyfD29tbZ6ZLQ5LJZIiMjERkZCTKy8tx8OBBLFmyBGFhYVi6dCliYmJM1rZcLoeTkxMKCgpQVFSkk8i4efMmAKB9+/Za8RpLPSP7woULGD58uOa4q6srdu/eDX9/fyxbtgyHDh2CnZ0dwsPDjW7j4MGDRp1vinGvbmyMGee63JOG1ljPBRE1DC5LJCKDmJubc+ZWA8nOzkZoaCjGjRuHsWPH4rfffmNii4iatLy8PBw+fFizjPD555+Hr6+vZhlhcHAw5s+fj9TUVM0ywqSkJJw7d07vMsKgoKCHLrGlNnLkSAB/LU9Uu337NpRKpRQh6XBwcIC7uzvs7e2xdetW2NvbIzQ0VJOwNAVnZ2ekpaUBACwtLREcHKzZ5W/79u0ma1dNPUvpwbZUKhX27dsHGxsbraWktra2uHv3rua9t7c3Vq9ebVAby5cvR15entZnbm5u2Lt3L5ydnXHixAkEBQU1SqLEFONe09gYM87G3hNTaIzngogaBmduEZFBOHOr/oQQ+OqrrxAdHQ1XV1fs37/fJPUsiIjqouoywqozsZRKJYqLiwFoLyMcPXo0Zs+eDV9f3xa7jNAUPvzwQ+zduxfR0dFwcnLC4MGDcfXqVcTExMDe3h4FBQVSh6jFw8MDGzduRHBwMMLCwnDw4EHI5XKTtDV16lSsWLEC3t7eKCgoQGJiIoQQePLJJ03SXlUfffQRfvzxR0RHR8Pe3h5Dhw5FdnY23nnnHWRnZ2PVqlVaywn79OmDY8eO4dq1a5rZiwEBATW2MXDgQMTGxiIuLg7+/v745JNPMHToUMhkMpw+fRrx8fGws7ODTCbDwoULoVAo8OKLLxrch1OnTmHEiBHw8fHBTz/9pFlmV5uGHveaxsaYcTb2nphCYzwXRNRAJK5oT9RkcbdEbfb29uLzzz+XOoxm6/LlyyIoKEiYmZmJqKgoUVxcLHVIjYa7JRI1HXfv3hUZGRliz549Ij4+XrMboUKh0OxGaGlpKRQKhQgKChJvvPGGWLVqldizZ4/IyMiQOvwWQ6lUitDQUOHo6ChsbGxE//79RXJysggMDNTch4kTJ4pjx45p3ld9VbVp0yadzyMiIvR+97333hNCCJ3jo0aNEuvXr9c5vnz5cr3XiYiIqLF/1e2WWF2sQgiRkpIipkyZIrp37y5sbW2Fq6urGDRokFizZo2orKw0anyN7bva7du3RXR0tPD09BSWlpaanQ337dun00ZaWpoICAgQdnZ2olOnTmLlypUGx5ecnCyefvpp0bp1a2FhYSGcnZ2Fn5+fWLp0qSgqKhJHjx4Vtra2WnGWl5fXet0TJ05oxq3qzouNNe5qtY2NMeNszLm1aUrPBXdLJGpwWTIhhGiwTBlRC5KQkIC4uDiTTsFvTpydnfHJJ59g8uTJUofSrAghsGbNGsycOROdO3fGf/7zn3rtdtUc+fv7o0+fPlixYoXUoRA9NPLy8rRqYKlnYimVSs0ScxcXF/To0UNTxF2hUKBHjx7w8fEx+c541LKtW7cOkZGRSExM1NoBkIjus7CwQL9+/XD8+HGpQyFqKbK5LJGIDMJlicbLyMjApEmTcPjwYcycORPz58832VIOInr45OfnIyMjo8ZlhM7OzvDy8tJZRujt7a13tz4iIiKi5ojJLSIyCAvKG66yshJr165FTEwMvLy8cPz4cfTt21fqsIioGSovL8e1a9d0diNUv4D7RaA7deoEhUIBPz8/zW6E6heRVKZNm4Zp06bBzs5Ok3AleljFxsZi8eLFUodB1GIxuUVEBuHMLcOkpqbilVdewenTpxETE4MFCxbAyspK6rCIqIkzdhlhUFAQlxFSkzVhwgRMmDChwa9ryO6Bc+fOxbx58xq87YdZUx/3ph6fWlxcHOLi4iSNgaglY3KLiAzCmVs1q6iowNKlSzF37lx0794dv/zyC3r37i11WETUhPzxxx+4ePEi0tPTcfHiRa1XSUkJgPsJrK5du8Lb2xsvvPACunXrhm7duqFr166wtbWVuAdE0mKpYGk09XFv6vERUeNgcouIDMKZW9U7e/YsXnnlFaSmpmL+/PmYNWsWZ1EQPaTy8vI0CasHk1gFBQUAAGtra3Tt2hVdu3bFU089henTp8Pb2xve3t5o06aNxD0gIiIian6Y3CIig3Dmlq7y8nIsW7YMc+bMQb9+/XD69Gn4+PhIHRYRmZhKpcKlS5d06l9VVwerT58+eO655zRLCj08PGBmZiZxL4iIiIhaDia3iMggnLmlLSUlBS+//DLS09OxYMECvPXWW/xllagFuXv3Lq5fv663kPvly5c1y2Dc3Nzg6+sLhUKhVQfL29sbFhb8MYuIiIioMfCnLiIyCGdu3VdWVoZ58+ZhyZIlGDJkCFJSUtC1a1epwyKiOqi6E2HVIu7nz5/HlStXNAl9fYXc1UksGxsbiXtBREREREYlt7799lv8/e9/BwDI5XKUlZWZJKiaLFmyBG+99RYAwN3dHdevX6/ztdatW4fIyEjN+8bepnjz5s149tlnNe9LS0thbW3daO0b4ueff8aiRYtw6tQpFBcXo2fPnhg3bhwiIyPh6upap2smJSVh3LhxsLKygkqlauCImz+pn4sHtykeOHAgjh8/zplbAI4ePYqJEyciKysLS5cuxfTp0zlbi6gZyMrK0llCmJqaivT0dFRUVAC4n8BSJ60iIyM1s7G8vb1hb28vcQ+IiIiIqCZG/VY2fvx4CCEQGBhYp8aKi4vRtWtXhISE1On7ADBr1iwIIdCrV686X+NBiYmJEEJoJbYaItbahIaGQgiBMWPGmKyN+jhy5Aj8/f1RWVmJI0eOIDs7GzNmzMDs2bPx9ttv1/m66mK5+ormNsa4N3VSPxdxcXEQQkAIoVUU/WGeuVVSUoLY2FgEBATAw8MD586dw4wZM5jYImpC8vLycPjwYaxevRqxsbF4/vnn0a9fP9ja2sLd3R3BwcGIjY3F3r17AQCjR4/G559/jpMnT6KgoAC5ubk4efIkkpKSMG/ePISHh6Nv375MbBERERE1A426LFEIgcrKymYx+6M5xVoTe3t79O7dG4cPHzb6u2vXrkVFRQXi4+Ph6ekJABg3bhx++umnes24qim51ZjjXp+xae7q0veHdebWoUOHMHHiRNy6dQuJiYmIioqSOiSih1ZeXp7O8sHMzEwolUrNP1A5OzvDy8tLUwMrKioKCoUCPXv2RPv27SXuARERERGZQqMmtxwcHJCRkdGYTdZZc4rVVNTFcnNycrRqCq1cubJe160pucVxb7rMzc0fquRWYWEh3n//fXz66acYOXIkDhw4AHd3d6nDImrxqiawqiaxLl68iMLCQgD3SyO4u7ujR48eWgkshUIBT09PyGQyiXtBRERERI2JBeWpWmFhYfjyyy8xffp0HD58uMGWZrRu3RoymUxvcouaLjMzs4dmWeKuXbsQFRWF4uJiztYiMoH8/HxkZGRoJbEyMzNx7tw55OTkAACsrKzQsWNHKBQK+Pn5aSWwPDw8uCyYiIiIiDRq/MkwLS0NoaGhcHJygp2dHQICAvQuY9q8eTNkMpnmpVQq8fzzz6NVq1aaY2vXrtU6R12M/sHvXrlyBePGjYOzszNatWqFkJAQg2byrFu3Tus6MplM8wOysR6MqWrhfJVKhTlz5sDHxwe2trZwdXXF6NGjsXXr1nr/4p+Tk2NQ3//880/ExMTAy8sLVlZWcHFx0cwsUVuyZAlkMhnu3LmDI0eOaPpizLbkXl5ecHR0xJkzZ/DMM8802AYC5ubmcHFx0UluNda4Gzo2d+7cQVFRUY3jrGbIPakrKZ6LLVu2YPHixRBCICsrC7GxsSgvL8eJEycQGxur9Tp27Fi9+9hU5OfnY8qUKRg5ciQGDRoEpVLJxBZRHRUXFyMlJQUbNmzAhx9+iJdffhl+fn5o27YtXFxc0K9fP0REROA///kPbty4gUcffRRz5szBnj17cOXKFZSWliIjIwN79uxBQkICoqKiNDsVMrFFRERERFpENS5evCicnZ2Fu7u72L17tygqKhJnz54Vw4cPFx4eHkIul+t8Z8yYMQKAGDp0qDhw4IC4c+eOOH78uDA3Nxe3bt3SOqe0tFTvd8eMGSOOHj0qiouLxZ49e4SNjY3o37+/Tlu9evUS7u7umvcVFRUiJiZGBAcHi9zc3Oq6peWrr74SAERiYqLez/XFOmnSJOHk5CR2794tSkpKRE5Ojpg1a5YAIA4cOGBQu9W1U7Xv+/btE46Ojjp9z87OFp6enqJdu3Zi27ZtoqCgQCiVShEWFiZkMplYs2aN1vl2dnbCz8/P6Jj2798vbG1tRXx8vCa+kJAQUV5erjln1KhRAoDmNXbsWIOv7+3tLRYtWqT3s8Ya95rGJjs7W7Rq1UqYmZnVOs7G3hNDSflcrF69WnNfzczMhFwu13lZWFgImUwmrl69Wqf+NTXJycnC3d1dtGvXTvzvf/+TOpwWxc/PT0yfPl3qMMgESktLxblz50RSUpKIi4sTUVFRIigoSCgUCiGTyTT/HXFzcxNBQUEiKipKxMXFiaSkJHHy5EmdnwWIiIiIiOogq9rkVnh4uAAgNm7cqHX8xo0bml9uH6T+ZXzHjh3Vtlhbcmvbtm1ax5977jkBQJMcU6ua3MrLyxMjRowQM2bMEBUVFdW2/aC6JLc8PT3FkCFDdM7t1q1bvZNbD/b9hRde0On7Sy+9JACI9evXa51bVlYmOnToIGxsbEROTo7meF2SW7du3RJOTk5ixIgRmms/+eSTAoAYP368uHfvnubczMxMYWNjY9S4C3H/l12px72msVGPs7Ozs9ZxfeNs7D0xlJTPRW5urrC0tNRKXj74kslkYsCAAUb3q7F99tlnNf4CnZubK6KiogQAER4eLm7fvt2I0T0cmNxq3vLz88WJEyfE+vXrxcKFC8WLL74ohgwZItq2bav574G5ublQKBRi+PDh4tVXXxXLli0T27ZtExcuXBAqlUrqLhARERFRy5ZV7bz+Xbt2AQBGjBihdbxDhw7o1q1bjbPBBgwYUOPnNenfv7/W+06dOgEAsrKy9J6vVCoxcOBAmJmZIT4+Hubm5nVu2xBPPfUUjh49iqioKBw/flyzJE6pVGLYsGH1uvaDfVcXr67a902bNgEARo0apXWuXC5HYGAgSktL8cMPP9Qrji+++AIFBQWIiIjQXHvLli0YMGAAvv32W0ydOlVz7sGDB+Hv72/0uFtYWBi1RNKU466PepzlcrnWcX3jbOp7IsVz4eLigqeffrrGc8zNzTFhwgSDrymF5ORkTJs2DfPnz9f7+YYNG+Dt7Y1t27Zh8+bNSEpKQqtWrRo5SiLp5eXl4dSpU9iwYQMWL16MKVOmIDg4GF5eXnBxcUH//v0RGRmJL774Ajdu3EDPnj0RExODpKQknDx5EoWFhcjIyMAPP/yAlStX4s0330RISAh8fHxgZWUldfeIiIiIqIXTm11QqVQoKiqCtbW13iLibdu2RXp6erUXtbOzq3NATk5OWu/VPxTr26UtLy8PoaGh6NixI3bu3Il169aZ/JftlStXYvDgwfjyyy8RGBgIAAgICMCUKVPw7LPP1uvaD/ZdXVNE3XeVSoWCggJYW1vDwcFB5/vt2rUDgDrXGlNT31v19QDA3t4eO3fuxNChQ7FmzRo4ODjg448/RkJCAt599916tWcIU477g9TjbGlpqXfHrarj3Bj3RKrn4sUXX8SWLVuq/fzevXsYO3asUddsTFeuXNEkaD/++GM899xz6Nu3LwDg5s2bePXVV7Fp0yZMmDABCQkJcHFxkTJcIpN7cBfCB1/A/X94eOSRRzSF29U1rhQKBXr06AEbGxuJe0FEREREpEtvcksul8PBwQFFRUUoLi7WSXDl5uY2SnC1sbCwwN69e+Hk5IQhQ4Zg8uTJ8Pb21pnp0pBkMhkiIyMRGRmJ8vJyHDx4EEuWLEFYWBiWLl2KmJgYk7Utl8vh5OSEgoICFBUV6SQybt68CQBo3769VrzGUs9cuXDhAoYPH6457urqit27d8Pf3x/Lli3DoUOHYGdnh/DwcKPbOHjwoFHnm2LcqxubquMshND5vOo41+WeNDRTPRcPzgKryszMDIMHD0aHDh3qGLVpqVQqPPvssygtLYUQQjPL7MyZM9iyZQumTZsGBwcH7N69G0FBQVKHS9RgqktgpaamIjs7GwBgaWmJTp066U1g+fr6wtraWuJeEBEREREZp9pliSNHjgTw1/JEtdu3b0OpVJo2KgM5ODjA3d0d9vb22Lp1K+zt7REaGqr5Ad4UnJ2dkZaWBuD+LwjBwcGaXf62b99usnbV1LOUHmxLpVJh3759sLGx0VpKamtri7t372ree3t7Y/Xq1Qa1sXz5cuTl5Wl95ubmhr1798LZ2RknTpxAUFBQnRJoxjLFuNc0NuoxUKlUWt/RN87G3hNTMMVzYWVlpdlN8UEymUwzK6opio6Oxm+//Yby8nIAQEVFBS5duoRRo0Zh/PjxiIiIwLlz55jYomapuiWEbm5ucHV11exCuHr1amRmZkKhUGDGjBlISkrCuXPnUFJSotmFcNWqVZg9ezbCw8PRt29fJraIiIiIqFmqtujRhx9+iL179yI6OhpOTk4YPHgwrl69ipiYGNjb26OgoKAx46yVh4cHNm7ciODgYISFheHgwYM69ZIaytSpU7FixQp4e3ujoKAAiYmJEELgySefNEl7VX300Uf48ccfER0dDXt7ewwdOhTZ2dl45513kJ2djVWrVmktJ+zTpw+OHTuGa9eu4fr168jMzERAQECNbQwcOBCxsbGIi4uDv78/PvnkEwwdOhQymQynT59GfHw87OzsIJPJsHDhQigUCrz44osG9+HUqVMYMWIEfHx88NNPPxm8pXtDj3tNY/PRRx9h27ZtyMvLQ3Jyco3jbOw9MQVTPRcymUzvkmAhBMLCwkzap7r69ttv8dlnn+kcr6iowP79+7F27Vq8/PLLEkRGZDh9M7BSU1Nx7tw5zd+/VlZW6Nixo9YMrB49esDX1xedO3c2eQ1KIiIiIqImo6Zy80qlUoSGhgpHR0dhY2Mj+vfvL5KTk0VgYKBmh6SJEyeKY8eO6d1NrapNmzbpfB4REaH3u++9954Q99eDab1GjRol1q9fr3N8+fLleq8TERFRYzn96nZLrC5WIYRISUkRU6ZMEd27dxe2trbC1dVVDBo0SKxZs0ZUVlYaU83f6L6r3b59W0RHRwtPT09haWmp2dlw3759Om2kpaWJgIAAYWdnJzp16iRWrlxpcHzJycni6aefFq1btxYWFhbC2dlZ+Pn5iaVLl4qioiJx9OhRYWtrqxVneXl5rdc9ceKEZtyq7rzYWOOuVtvYfPDBB8LOzs6gcTbmntSmKT0X5ubmwsrKSqtNMzMzMWzYMKP71RjS0tKEra2tkMlkev+bZGFhIXr27Cnu3r0rdagPFe6WqF9ubq44efKkSEpKEnFxcSIyMlL07dtXODo6ap5ZKysroVAoRFBQkIiKihLx8fFiz549IiMjw+hdaomIiIiIWqgsmRB6igo9JNatW4fIyEgkJiZq7QBIBAAJCQmIi4sz6TLXps7CwgLt27fHH3/8oVniZ25ujs8++wyTJk2SODptd+7cweOPP47Lly+joqKi2vPMzc2xaNEixMbGNmJ0Dzd/f3/06dMHK1askDqURld1BlZqairOnz+PzMxMXLx4EYWFhQB0Z2CpZ18y0YYxAAAgAElEQVQpFAp4eHgYPLuViIiIiOghlV3tskQiIgBo3bo1srKytI419A6VDWHSpEm4cuVKjYkt4P4uj3PmzEFoaCh8fHwaKTpqyapLYKWnp6OoqAjA/Y0f3N3doVAo4Ofnh6ioKE0yiwksIiIiIqL6YXILwLRp0zBt2jTY2dmhuLhY6nCIJBUbG4vFixdr3ltbW6N3795ISUmBmZkZAgMDNTtqNhWJiYn47rvv9O5uqWZubg6ZTIaKigrY2dlh06ZNeOeddxoxSmquKioqcPXqVVy6dAkZGRma16VLl3Dp0iWUlZUBAOzt7dG1a1d06dIFw4cPx6uvvoouXbqgS5cuTXZnUSIiIiKiluChTm5NmDABEyZMaPDrGrJ74Ny5czFv3rwGb/th1tTHvanHpxYXF4e4uDitY//617/w5ptvQgiB8ePHSxSZfikpKYiOjtZJbFVNZtna2mLQoEEYPnw4goKC8Pjjj3OmDGkpKytDZmamVgJL/efff/9dsyzXxcUFXl5e8PLywjPPPIMuXbpoElrt27eXuBdERERERA+nhzq5ZSoPcRkzSTX1cW/q8dVk/PjxePPNN2FmZoYxY8ZIHY5GXl4eQkJCcPfuXc3OcPfu3YOTkxOGDRuGwMBADBs2DD179jQouUgtW1lZGTIyMjTLBqu+fv/9d9y7dw/A/QSWesng2LFjNX9Wv4iIiIiIqGlhcotIQlevAjt2AL/8Apy/AOTnA3fvSh2VPm1gJQ+GDDL06+8qdTD/R+Bmzj9QUnIDZmZOkFv/DS4uT8JLMQz+/j0RFCSDvz9gaSl1nNSYqta/evB1+fJlTZLZxcVFU7g9KChIk7jq2rUrHB0dJe4FEREREREZg8ktIgns2gV8sgQ4sB+wtRV4vP89+D5+D87OlbC0kjo6/S6c+zuEuIcej5ZKHQoAICfrV9y4/jc84jEPbdp0B2QyFBXKcOOaGb7bIPDhhzK0aw9MngTMnAk4O0sdMTUUdQKravH22nYgrJrA6t69O2xtbSXuBRERERERNRQmt4ga0cWLQEwMkJwM/C24HJ+vV8F/aDms5FJHVruysmDcq6iAnX2Z1KH8nx7/9wIAlc6nV6+YYeN6ORI/k2PVahk+/AB45RWApbaavvLycly7dk3v7KsLFy6gpKQEwP3NDjp06KB3B8LOnTtrlqoSEREREVHLxuQWUSNZufL+DCJPr3tYv6UEgwMqpA7JKNbW1lKHYJRHPCoR804pJr1ahvjFNnj1VTn+3/8D/vc/oF07qaMjlUqFGzduaJJWVWdhVVf/KigoSCuB5enpyVpqRERERETE5BaRqd27B0RH309uxbxTimnRZbDg//MajaOTwJwPSzAuUoWp/7DHgIFmSN4GPPqo1JG1fOrlg7dv38apU6cwZcqUautfqRNW4eHhmlpYXbp0gZOTk8S9ICIiIiKipo6/YhOZ0L17wHPPAT/sBlZ+cQdPP9Mkq8U/FLy738Om3YWY9qI9/PwssGcPMHCg1FE1f/oKuKempiI1NRX5+fkAAJlMBkdHR9ja2urUv/Lx8YGdnZ3EvSAiIiIiouaMyS0iE5o1C9j1A7Du+yL0G9i8liG2RM4uAv/dWIQp/7DHM2Ms8cvPQOfOUkfVtFVUVODq1at6618plUoUFxcDAORyOdzd3aFQKODr64vRo0drZmBFRkaib9++WLFihcS9ISIiIiKilojJLSITWb0aSEgA/rX2DhNbTYil1f178txIB4x+xhxHjwD29lJHJa27d+/i+vXrehNYqampKCu7v4lATfWvPDw8YFZNtX7WxSIiIiIiIlNicovIBK5dA958E5g+qwwhz3IpYlNjZy/w+fpijBrmiPnzZfjkE6kjMr2ysjJkZGRoirZXfV25cgWVlZUAqk9g+fr6ws3NTeJeEBERERER6WJyi8gEZs0C2ravxOsxpVKHQtXo0LESM98txYJ3bTFpEuDtbfw17t27h/Ly8iazk6S++ldVX2pubm7w9fXVqX/VrVs3ODg4SNgDIiIiIiIi4zG5RdTADh8GkpKA/3xbAiu51NFQTf7+ogrf/D85Zs0yx7Zthn+vsrISGzduxNy5c7FixQoEBwebLsgH5OXlITU1VWcG1sWLF1FYWAgA/5+9Ow+Lql78OP4Zhm1ghi1NRMsNt5KLuWCmKblVajeyX2W53DazLJdQM7Nb92Z1u6kplrZpZZlpWZpm2rXSysqt0jbDLc1cURx2ZDu/PyYnCVBB4MzA+/U888ic8z1nPjMoT3z6nu+Rv7+/GjZsWGwG1smvL7roItlstmrLCwAAAABVjXILqGTTp0sdLy1Qjz75ZkfBGVit0thJObrzFru2b5datDj9eMMwtHTpUk2aNEm//PKLJGnXrl2VWm7l5+dr3759pc682rZtm7KzsyVJgYGBioqK0kUXXVRi/atGjRrJarVWWiYAAAAA8GSUW0Alcjql5culp589YXYUnKUreuerflSR5s/30WOPlT3u448/1vjx47VlyxZZrVYZhiF/f/9il/udrRMnTmj//v3uBdtPnYW1d+9eFRYWSjr9Au5NmjRhoXYAAAAAEOUWUKlWr5YMQ+p5JbO2vIWPj9Tr6nyt+DCg1HJr3bp1mjBhgr766iv3bKiT5VN+fr527NhR6nlPt/7Vr7/+KsMwJBUvsIYMGeJeCys6OlqhoaFV86YBAAAAoAah3AIq0caNUsvWhQoJNcyOgnLo0KlAC14L0IkTUsAf66R9+eWXmjhxor744gv5+rp+VJ4stU4yDENbtmzR3LlztXPnTu3atcv9SEtLk+Ra/6px48aKjo5W69at1b9/f0VHR6tZs2Zq0qSJAgJYmA0AAAAAzgXlFlCJdu6UmkQXnnkgPEp0i0IVFEh790qpqev173//W6tWrXKXWgUFBWUeu2/fPt17771q0KCBmjZtqg4dOmjo0KHuGVhnWv8qLy9PWVlZyszMVF5enpxOZ7Ft+fn5SktLU1FRkXu7JKWnp6uwsFAFBQXKyMiQJPd4ScrKylJeXl6x1zp+/Hix5/n5+crMzCz/B/YHh8Ph/owkycfHp8RsM5vNpuTkZKWkpGj48OGSXLPVTj0+KChIAQEBCggIUHBwsMLCwmS32xUUFCS73a6wsDAFBwdTBAIAAAAoFeUWUImcaVKDxuc+a2v5e+9p5J13SpL8AwK0/eDBczrf/1as0F1DhrifJx88SFFwitAwQ9ImDR36sDZs+N9ZlVonFRYW6pVXXpGvr68yMzN1/PhxHT16VCtWrFBmZqbS0tKUlpamzMzMYo+TRdbZOFkC+fr6yuFwSJKCg4Pl7+9frFA6WRJJUkREhIKCgko9z0mllVHl4XQ63ZdXSipWvp10sjwrKCjQ7t27VVRU5J7VdvL4jIwMFRQUKCcnR7m5uWW+ntVqVUhIiEJCQhQWFqbzzjtPERERqlOnjiIiIhQREeHeFhERofr16ysqKsr0u0MuXLhQN998syQpICDgtO+xqkydOlXjx4+XJDVo0EC///57tWcAAAAAqorFOPU3EwBuSUlJeuqpp3SwHMVS18ulFhef0KP/ya6UDIOuu06b1q8vVm5lZWWpX/fuahodrVcWLizX+YYNHqzVH35oSrl1Lrmr2jsLVmn8fU/IYtkmwyiSj4+PDMNQeX48+vn5yeFwKCwsTA6HQ3a7XXa7XSEhIQoNDXU/t9vtcjgc8vPzU1hYmPz9/RUcHCy73S4/Pz+Fh4fLz89PdrvdXWB5u65du6pdu3aaOXPmGceeLL8yMjKUnZ2trKwsOZ1OZWVlKTs7W+np6UpPT5fT6dSxY8fcj9TUVPeffy3YwsPDFRUVpaioKNWvX18NGjRQVFSUmjVrpubNm6tRo0by8/Orqrfv1qtXL61bt67c5VZmZqYuueQStWzZUh988ME5ZWjbtq2OHj1KuQUAAICa5CAztwBvYxgqKipSUVFRiV0XNWyoi2JitHjlShOCncFpcputW4++kuLkcMQpNDRYvr6+7ssBMzMzZRiGfHx8JKlEfh8fH82dO1e33npr9QevgXx8fBQeHu6+dLEicnNzlZqaqgMHDujgwYPav3+/+89Dhw5p69atOnDggFJSUiS5islGjRqpefPmio6OVqtWrXTJJZeobdu2ps/6klxru3nqvx0AAADAE1BuAV4m2G7X599+a3aMcvP83M20YsUxde1afGtGRoa+/fZbbd68WZs2bdLXX3+t3377TZJrsfj8/Hzt3bvXhLwoS2BgoHum1umkpaVp586d2rlzp3bs2KEdO3Zo8+bNevPNN5WamipfX19dfPHF6tChgzp06KCuXbuqTZs21fQu/uRwOLRr165qf10AAADAW1BuAcBpOBwOde/eXd27d3dvczqd2rx5s7vwMmMNJZy70NBQtW/fXu3bty+xb9euXcW+x2+//bYyMjLUsGFD9e3bV4MGDdLll18ui8ViQnIAAAAAp/IxOwAAadeOHRo2eLDaNGqk1g0a6Ia+fbVp/foS4/63YoUaR0S4HydOnJAkvfTcc2ocEaHs7Gxt3rDBvb9Z3bqlvl7K4cO67/bbFdO4sdo2a6bbBw7U3l9/LTEu9ehR/evBB9UlNlbR9eqpXfPmGj50qH7+4YcyM+3euVP33nab2jZr5t628I03Ss3912N//+23s8p16ufVKipK1/bsqU8++kiDrrvOfa4Jo0ZV6HtxNsLCwtSrVy89+OCDevfdd/Wf//ynyl4L5mjWrJluuukmTZkyRWvXrpXT6dSGDRs0bNgwbdiwQd27d1fLli316quvqrCw+B1Sf/nlFyUkJCg0NFTBwcG6/PLLtW7duhKvsXTpUlksFvcjOTlZN954o8477zz3tjlz5hQbc7JI/euxe/bs0U033eReaL9///5nNdtr/vz5xc5jsVh06NChyvkQAQAAgGpCuQWYbM/u3bquTx/98N13en7ePG3evl2Tp07VzClTShQ7ffr1057UVPXu27fY9rvuu097UlMVFBSkDp06aU9qqvakpmrXH2sK/dW/H3pIt99zjzb8/LNmv/qqNn79tUb9cXfGk44cPqxrevbUB0uW6PGpU7V1924tXL5czuPHdV2fPvp206ZSM028/34NueMOff3jj1q6erWsVqv69O1bau6/HntqrudeeUVfff55iVx//by+2bFDU2bN0qsvvKBtP/0k/4AA7UlN1X/PYvFy4Gz5+PgoLi5OjzzyiLZs2aIffvhB3bp109133634+HgdPnxYkrRz50517txZmzdv1uLFi3X48GHNnj1bkydPLlE2JSQkyDAMXXvttZKk4cOHa8SIEdq3b5/Wr18vq9VaYkxZx44ZM0ZjxozR/v37tWjRIn366afuOzSezs0336zExET17t1bqampMgxDkZGRlfGRAQAAANWGcgsw2ZTJk5WelqZHn3pKl8fHKzg4WK0uukhTZ83SkT9+Ya5sA4cMUbuOHRUUFKTLunVTzyuv1NbvvlPqsWPuMf997DHt37dP/3ziCV3Ru7eCg4PVolUrPTd3rgxJj06YUOq57xk9Wpd27Sqbzaa27dtrV0qKIs47r9y5unbvrh59+pTIVdrn1aJVK818+WXl/OUueUBVadOmjebMmaPNmzfryJEjGjBggCTpoYcektPpVFJSknr37i273a6YmBi9+uqrZ7zz6oQJExQfH6+goCB16tRJBQUFqlOnzlnlufPOO9W5c2cFBwerV69e6tevnzZt2qSjR4+WeYzT6VS/fv1UWFiolStXntMi/gAAAICZKLcAk6395BNJUrcePYptrxcZqabNmlXJa8a2a1fseWT9+pKkI6dcjvS/FSvk4+OjnldeWWxs3fPPV4tWrfTDli06eODAGc99LrnqN2hQIldZn1dEnTpq1qJFhV8bqIiYmBi9/vrr+uqrr7Rjxw6tWrVKknTlX/7dREVFqcUZ/n7GxcVVOEfHjh2LPb/gggskSQdK+TcqScnJyerUqZN8fHw0Y8YMWa3WCr82AAAAYDbKLcBEeSdOKCszUwEBAQoODi6x/7wy1sw6V46QkGLPfXxcPwqKiorcuTLS01VUVKQ2jRoVWxercUSEfty6VZK0p5Q1fYJKeR8VzeXv718i1+k+r9CwsAq/NlBRGzdulNVqlcPhUEZGhgIDA2W320uMO//88097ntL+Tp+t0NDQYs//+m/nVMePH1dCQoIaNmyolStXav78+RV+XQAAAMATcLdEwET+AQEKttuVlZmprKysEr/cOo8fL9f5KuvObf4BAQoJDVV2VpZ+OXBAvr6e8aPiTJ/XsTLWGKsqhmFoy5Ytatq0aYlyATXfsWPH9Nhjj+nZZ5/VE088ocjISHfBlZmZWaLgSk1NNSlpcb6+vvr4448VGhqqyy67TMOGDVPLli1LzP4CAAAAvAUztwCTXdGrlyTpsz8utzsp9dgx7d6xo1znCgwKUn5e3p/n7thRC+bNq1Cuq/r3V0FBgb7ZsKHEvueTktQ5JkYFBQUVOve5KOvzSjlyRLvP4u5w5+rIkSN68803NWTIENWpU0ft2rWT0+ms8teFZ8jPz9fKlSt16623qkmTJlq4cKFef/11TZw4UZJ09dVXS5L78sSTjh49quTk5GrPWxqHw6EGDRrIbrdr2bJlstvtSkhIOOOaYAAAAICnotwCTDb+n/9UWHi4Hps4UV+sXausrCztSE7WmOHDFVTKpU2n0+Zvf9PuXbt0cP9+fbtpk/bt3au4zp0rlGvCI4+oUZMmGj9ypNZ+/LEy0tPlPH5cC157TTOfflqTJk82ZUZXaZ9X8rZtGnfvvap7hsu+KiI/P1+fffaZJk2apNjYWEVGRmro0KFatGiReyYOC3HXXEVFRfrxxx/10ksv6R//+Ifq16+vfv36afv27Xr88ce1a9cuDR482D3+ySefVEREhMaMGaPVq1crMzNTP//8swYPHlzqpYpma9y4sRYvXqyUlBQNGDBAJ06cMDsSAAAAUH4GgFLNmDHDiIyMLNcxXboaxm3Dc409qanleqzZtMno06+fYXc4jMDAQCP2kkuMVxYuNLp0725IMiQZNw0ebLz0xhvu5ycfCTfc4D7Ppxs3GnGdOxtBQUFG/QYNjMlTphh7UlONJf/7X4nj7hs71tiTmlpie48+fdzn27Jrl3HniBHGhY0bG75+fkZEnTrG5VdcYcxfssQ9prRzSyr2/srKXdFcp35eNpvNaB8XZ7z9wQfGpV27Gjabrdyf/4afnYZkGF984fo+7t6923jxxReNAQMGGHa73ZBkBAQElPo+rVarUVRUVAV/A2uOLl26GCNHjjQ7xhmlp6cbmzZtMl5//XVj4sSJxlVXXWWEhoYakgyHw2H07NnTePrpp409e/ac9jzJyclGQkKCERISYthsNqNjx47GBx98YPTs2dP99+aOO+4wvv7661L/Tp1qyZIlJfYPGjSo1GMnTZpkGIZRYnu/fv2Mt956q8T26dOnl3qeQYMGVdlnDAAAAFSBAxbDMIxzbsiAGigpKUlPPfVUuS7V6Xq51OLiE3r0P9lVmAxl6REXp9zcXH31/fflOm7Pr7mKb/+Nrr/+I33zzQfas2ePe1bamS69DAkJUVpaWoUz1wZdu3ZVu3btNHPmTFNz5OXlaf/+/dq3b5/27t2rffv2ad++fdq5c6d++eUX/f7775Jci7G3aNFCsbGx6ty5s7p06aKYmBjuKAgAAAB4poOesUo0AJyllCNH1OvSS/VNcrJ8/fzc23//7Tf9tmePEm68sVznKyws1AfvzZf0ot599881u852PTFfX1/NmDFDQUFBCgsLk81mk81mU3h4uPvrsLAwBQUFKSAgoFzZcHpFRUVKS0vT8ePHlZKSoqNHj+ro0aNKSUnRoUOH3F+npKTo999/16FDh3Ty/+cEBASoYcOGatiwoaKjo9WnTx+1atVKrVu3VpMmTSiyAAAAAC9CuQVUMuZCVr00p1MTExOV+OCDCouI0PZt2/TIAw/I7nBo1Lhx5TqX1WrVDYPu0tQnxmrGjE+1atU0ffTRR/Lz81PeKYvzlyUvL09Tp05Vdna2nE6nTjcZ1sfHR6GhoQoODpbNZlNISIjsdrtsNpscDoccDodsNpvsdrtCQkJks9ncd4QMDAyUzWYr8XVAQICCgoJKfO3v7+8+9tSvq1NGRoYKCgpUUFCgtLQ07d69WwUFBcrIyJAk5eTkKDc3V2lpacrPz1d6erp7W3p6uvLy8pSenq7MzEylpaXJ6XQqLS3N/fXJ85wqKChIderUUb169VS3bl3VrVtXrVu3VsOGDXXBBRe4H5GRkZV2d1EAAAAA5qLcAipRcLCUm2N2ipqt7vnn680lS/T63Lm6oV8/HT50SKGhoeoaH6+ZL7+sCxs3Lvc5s7MsknwUH99Lo0f30s6dOzVnzhzNnj1b2dnZKioqKrO0iouL0yen3LkxNzdXOTk5On78uHJycpSTkyOn06ns7Gzl5OQoLS1NmZmZysnJUUZGhjIyMpSTk6PMzEzt379fOTk5ysrKUlpamnJycpSd7brENSsr66zKtjOp7KLrZBl1Jhs2bNDrr79e5n6r1eou9AIDAxUaGip/f385HA7Z7XbVrVtX0dHRCg0NVWhoqMLCwtxfh4eHq06dOqpTp44pJR4AAAAAc1FuAZWo3vnS/sPchLSqdeneXV26d6+086Uccc3gqVvX9Tw6OlpPPfWUJk2apLfeektTp07Vjh075OvrW+xyRYvForonD/pDYGCgAgMDq/QOitnZ2e672p369alF06lfnyzc/vp1ZQkODpa/v3+Z28eMGaOLL75YDzzwgCwWi8LCwiT9OQMtJCSEywABAAAAVBjlFlCJLr5YWv0J/6y8zc8/WBUWLkVFFd/ucDh01113adiwYVq9erWSkpK0cuVK+fr6Kj8/X1ar1V3UVKegoCD35YdVWaJVlrCwMNWrV0/t27c3OwoAAACAGogpJkAl6tZNOnTAoh3JzELxJl+s8VP8aSaCWSwW9enTRytWrNCOHTs0atQo2e12FRQUeEW5BAAAAAA1GeUWUIni4qTI+tKyd0teogXPlHrMoi/W+unaa89ufLNmzTR16lQdOnRIL7zwgi655JKqDQgAAAAAOC2unwIqkdUq3XmH9OJLAbp7dK6Cg7l1oqeb/0qAbIHSDTeU77jg4GANHz68akIBAAAAAM4aM7eASnb//VJhoUWzngk0OwrO4NBBH704M1APPOC60yUAAAAAwPtQbgGVLCJC+tej0pxZgfp1F2tvebL/PGrT+fUsSkw0OwkAAAAAoKIot4AqcM89UstW0pjhwcrNtZgdB6VY8ra/lr3rrxnTpUAm2QEAAACA16LcAqqAr6/0/lLpwD6r7r87WEVFZifCqTZv8NWE0cF64AHp7383Ow0AAAAA4FxQbgFVpEkT6Z13pE9W+enRCUEqLDQ7ESRp63e+umuwXX2vlp580uw0AAAAAIBzRbkFVKHu3aUFC6TFCwI07Ba7sjK5RNFMHy7z18BrHIqLs2j+fMmHn4AAAAAA4PX41Q6oYtdfL61dK/30g5+u6+PQxq99zY5U62RmWPT4wzbde1uw7rxD+mA5d0cEAAAAgJqCcguoBnFx0qaNUpNGVt3U36HRw4K1fx///KpaQYH0zpv+6hEXqvcWBWruXGnmTMnKTSwBAAAAoMZgCglQTS64QFq1Slq+XLo/0V/d2vnrit75uqp/njp1KVDDC4tk4arFc5aZYdFP31u1ZrWfli4O0NEjFt19t/Tvf0sREWanAwAAAABUNsotoJpdc4105ZXS0qXSa6/56eFxfsrNlWxBUli4IX8/w+yIlaKoqPrXtEpLsyjNaZFhSNHNpdtvle6807W4PwAAAACgZqLcAkzg7y/deKPrkZ0tff+9tG2b5HRalJfn/dO3du+W5s2Txo2THI7qe93QUCkqSoqNlRo1qr7XBQAAAACYh3ILMFlQkHTppa5HTXHihLRsmWv21oQJZqcBAAAAANRkrGgNoNIFBEgjRkgvvCBlZpqdBgAAAABQk1FuAagS994r5eVJr71mdhIAAAAAQE1GuQWgSkRESEOGSM88IxUWmp0GAAAAAFBTUW4BqDKJidLevdL775udBAAAAABQU1FuAagyzZtL/ftL06aZnQQAAAAAUFNRbgGoUmPHSl99JX39tdlJAAAAAAA1EeUWgCrVrZvUqZNr7S0AAAAAACob5RaAKjdmjLRkibRrl9lJAAAAAAA1DeUWgCp3ww1So0bSzJlmJwEAAAAA1DSUWwCqnNUq3XefNGeOdOyY2WkAAAAAADUJ5RaAanHnnZK/v/Tyy2YnAQAAAADUJJRbAKqFw+EquJ59VsrLMzsNAAAAAKCmoNwCUG3GjJFSUqSFC81OAgAAAACoKSi3AFSbBg1ci8tPnSoZhtlpAAAAAAA1AeUWgGr1wAPSDz9In3xidhIAAAAAQE1AuQWgWsXGSvHx0rRpZicBAAAAANQElFsAqt3YsdKqVdL335udBAAAAADg7Si3AFS7fv2k1q2lpCSzkwAAAAAAvB3lFoBqZ7G47pz45pvSwYNmpwEAAAAAeDPKLQCm+Mc/pPBwadYss5MAAAAAALwZ5RYAUwQESHffLT3/vJSVZXYaAAAAAIC3otwCYJoRI6ScHGnePLOTAAAAAAC8FeUWANPUrSsNGSJNmyYVFpqdBgAAAADgjSi3AJhq7Fhpzx5p+XKzkwAAAAAAvBHlFgBTtWgh9e3rmr0FAAAAAEB5UW4BMN3YsdK6ddL69WYnAQAAAAB4G8otAKaLj5fi4qTp081OAgAAAADwNpRbADzC6NHSu+9Ku3ebnQQAAAAA4E0otwB4hBtvlBo0kJ591uwkAAAAAABvQrkFwCP4+kqjRklz50pOp9lpAAAAAADegnILgMe46y7Jx0d66SWzkwAAAAAAvAXlFgCP4XBId9whzZwp5TkkHLYAACAASURBVOWZnQYAAAAA4A0otwB4lPvvl44ckd5+2+wkAAAAAABvQLkFwKM0bChdf700ZYpkGGanAQAAAAB4OsotAB5n3Djp+++lNWvMTgIAAAAA8HSUWwA8Tvv2Urdu0rRpZicBAAAAAHg6yi0AHmnsWGnlSunnn81OAgAAAADwZJRbADzSNddIrVpJ06ebnQQAAAAA4MkotwB4JItFGjVKeuMN6dAhs9MAAAAAADwV5RYAj3XrrVJYmPT882YnAQAAAAB4KsotAB4rMFAaPlx67jkpK8vsNAAAAAAAT0S5BcCj3XuvlJPjujwRAAAAAIC/otwC4NHOP18aNEh65hmpqMjsNAAAAAAAT0O5BcDjjRsn7dolffCB2UkAAAAAAJ6GcguAx2vZUrrqKmnaNLOTAAAAAAA8DeUWAK8wdqz0+efShg1mJwEAAAAAeBLKLQBeoUcP6ZJLpBkzzE4CAAAAAPAklFsAvEZiovTOO9Kvv5qdBAAAAADgKSi3AHiNm26SGjSQnnvO7CTFTZ06VRaLRRaLRQ0bNjzjdgAAAABA5aHcAuA1/Pyk++6TXn5ZcjrNTvOncePGyTAMxcbGntV2AAAAAEDlodwC4FWGD5d8fKQ5c8xOAgAAAADwBJRbALxKSIh0222uheXz881OAwAAAAAwG+UWAK8zZox0+LBrcXkAAAAAQO1GuQXA6zRqJA0YIE2bVvaYhIQE92LuFotFXbt2de/75JNPZLFYtHz5cve2MWPGFBtfUFCggoICLVq0SL1791ZkZKRsNptiYmKUlJSkoqKiCuefP39+sdeyWCw6dOhQhc8HAAAAALUZ5RYArzR+vPTtt9LataXvX7p0qWbNmiVJevPNN7Vu3Tr3vvnz57u3nzRjxgwtWbJEPXv2lGEY8vX11apVqzRw4ED16NFD27Zt0759+3TXXXcpMTFREyZMqHD2m2++WYmJierdu7dSU1NlGIYiIyMrfD4AAAAAqM0otwB4pQ4dpK5dTz97a+DAgfL399cbb7zh3paTk6P3339f0dHRWrZsmTIyMtz7Xn/9dQ0dOrTYOeLj4zVx4kSFh4erTp06GjlypG655RYlJSUpPT293LmdTqf69eunwsJCrVy5UuHh4eU+BwAAAADgT5RbALzW2LHSihXStm2l74+IiFDfvn21evVq92V/77//vjp16qR7771XOTk5eu+99yRJqampWrt2rQYMGOA+vn///lqzZk2J88bGxio/P18//fRTufImJyerU6dO8vHx0YwZM2S1Wst1PAAAAACgJMotAF7r73+XWrZ03TmxLEOHDlVhYaEWLFggSXrjjTc0dOhQ3XzzzbJare5LE9966y31799fdrvdfWxaWpoeeeQRxcTEKDw83L0+1vjx4yVJ2dnZZ531+PHjSkhIUMOGDbVy5Ur3pZEAAAAAgHNDuQXAa/n4SCNHSvPmue6eWJp+/fopIiJCb7zxhlJSUrR+/XolJCSoXr166tOnjz799FMdPHhQ8+bNK3FJ4jXXXKPJkydr2LBh2r59u4qKimQYhqZPny5JMgzjrLP6+vrq448/1vvvv6+YmBgNGzZMmzZtqvB7BwAAAAC4UG4B8Gq33io5HNLzz5e+39/fXzfddJO2bNmiSZMm6dprr5XNZpMkDRkyRIWFhXr00Ud18OBB9ejRw31cYWGhvvzyS0VGRmrUqFGqW7euLBaLJNe6XeXlcDjUoEED2e12LVu2THa7XQkJCTp48GC5zwUAAAAA+BPlFgCvFhQk3X23NHu2VFbnNGTIEEnSyy+/XGx2VkJCghwOh15++WUNGjRIPj5//ki0Wq2Kj4/XoUOHNGXKFB09elQ5OTlas2aNXnjhhXPK3LhxYy1evFgpKSkaMGCATpw4cU7nAwAAAIDajHILgNcbOVLKyJBOuSliMZ07d1bz5s114YUXqnv37u7tNptN119/vSSVuCRRkhYtWqThw4fr2WefVVRUlJo0aaLXX39dt9xyiySpd+/e6tChg6ZOnSqLxaKtW7dq//79slgsevjhh7Vw4cIS22fMmKH169crPj5e+fn5Wr9+vQIDAzV48ODK/2AAAAAAoBawGOVZNAaoRZKSkvTUU09x2ZiXuOMOad06150TfajtPUrXrl3Vrl07zZw50+woAAAAAGqeg/wKCKBGGD9e2rFD+vBDs5MAAAAAAKoT5RaAGqFVK+nKK6Vp08xOAgAAAACoTpRbAGqMsWOltWuljRvNTgIAAAAAqC6UWwBqjF69pLZtpaQks5MAAAAAAKoL5RaAGuX++6W335Z++83sJAAAAACA6kC5BaBGuflmKTJSevZZs5MAAAAAAKoD5RaAGsXPT7r3Xumll6S0NLPTAAAAAACqGuUWgBrn7ruloiJp7lyzkwAAAAAAqhrlFoAaJyxMuv12afp0KT/f7DQAAAAAgKpEuQWgRrr/funQIendd81OAgAAAACoSpRbAGqkxo2lhARp6lSzkwAAAAAAqhLlFoAa64EHpG++kT7/3OwkAAAAAICqQrkFoMbq2FG67DJp2jSzkwAAAAAAqgrlFoAabexYaflyads2s5MAAAAAAKoC5RaAGi0hQWrWTJo50+wkAAAAAICqQLkFoEbz8ZFGj5bmzZOOHjU7DQAAAACgslFuAajxbr9dCgqSZs82OwkAAAAAoLJRbgGo8YKCpOHDpVmzpJwcs9MAAAAAACoT5RaAWmHUKCk9XXrzTbOTAAAAAAAqE+UWgFqhXj1p4EBp6lSpqMjsNAAAAACAykK5BaDWGDtW2r5dWrXK7CQAAAAAgMpCuQWg1mjTRurdW5o2zewkAAAAAIDKQrkFoFYZO1b69FPpu+/MTgIAAAAAqAyUWwBqlT59pNhY6ZlnzE4CAAAAAKgMlFsAap0xY6RFi6R9+8xOAgAAAAA4V5RbAGqdQYNcd0987jmzkwAAAAAAzhXlFoBax89Puuce6YUXpPR0s9MAAAAAAM4F5RaAWumee6SiIumVV8xOAgAAAAA4F5RbAGql8HDp1lulGTOkggKz0wAAAAAAKopyC0CtlZgo/f679N57ZicBAAAAAFQU5RaAWqtJE+naa6UpU8xOAgAAAACoKMotALXa2LHS5s3SunVmJwEAAAAAVATlFoBa7bLLpM6dpWnTzE4CAAAAAKgIyi0AtV5iorRsmfTLL2YnAQAAAACUF+UWgFrvuutc6289+6zZSQAAAAAA5UW5BaDWs1qlUaOk116Tjh41Ow0AAAAAoDwotwBA0h13SDab9OKLZicBAAAAAJQH5RYASAoOloYNk2bOlHJzzU4DAAAAADhblFsA8IeRIyWnU1qwoPj2o0elhQvNyQQAAAAAOD3KLQD4Q1SUNHCg9MwzkmFI27dLd98tNWggPfyw2ekAAAAAAKXxNTsAAHiSxESpY0fpiiukzz+X/PykvDzpyBGzkwEAAAAASsPMLQCQVFQkLV8u3XmnlJ8vffmla/ZWXp5rf2bmn18DAAAAADwHM7cA1GoZGdKcOdK0adKBA5LPH5V/QUHxcYbhWnsrKqr6MwIAAAAAysbMLQC1mtPpWmPrwAFXgVVYWPZYLk0EAAAAAM9DuQWgVrvgAmnNGum88yTfM8xlPXy4ejIBAAAAAM4e5RaAWi862lVwBQdLVmvpY3x8mLkFAAAAAJ6IcgsAJLVpI61dKwUFlV5w+fpSbgEAAACAJ6LcAoA/tG0rffSR5O9fsuCyWKSUFHNyAQAAAADKRrkFAKfo3Flatsx1GaLPKT8hCwqYuQUAAAAAnohyCwD+olcv6Z13XLO1LBbXtsJC6eBBc3MBAAAAAEqi3AKAUlx7rfTaa8W3HThgShQAAAAAwGlQbgFAGQYPlp5//s/ZW1yWCAAAAACex9fsAABwTnJzXVOqjh+vktMP7yDlJp6vMdMuUOoxQ/rm2yp5HVOEhEj160t2u9lJAAAAAKDCKLcAeJ+NG6VFi1y3NkxOdq32XoVGS0rVv/VY/iPK6HCFHMqo0terVhaLFB0t9ewp/d//ST16/DlVDQAAAAC8AOUWAO+xbp00dqyr3GrVSurXT3r0UalpUyk8vEpf+t+Scp5y6sgtP8lxYX6Vvla1SU+X9u6VvvlG+vBD6YUXpJYtpf/+17XoGAAAAAB4AcotAJ5v/35p/Hhp4UKpTx/pyy+lyy6r9hj/fVHKzQ2TbNX+0lWnbVtXkfXYY9KPP0r/+Y903XWuW0bOnOkqEQEAAADAg7GgPADP9tVXUrt20qZN0tKl0qpVphRbkutqPVtNKrb+qk0b6c03pS++kFJTpQ4dXJ85AAAAAHgwyi0Anuvtt10ziNq3d1069/e/m52odujSRdqwQbr9dmnAAOlf/zI7EQAAAACUicsSAXimRYukm2+WEhOlp5+WfM6ii//tN9faURs3Sj/+KMN5XMrLq/qsns7XVwoLl6VlC6lDR6lvX9faWqdjtbouS2zWzLXOmc0mTZhQPXkBAAAAoBwotwB4nm++cc0aGj1amjr1zONXrXIVYGvXyggIUH7TBiqIPE9GvSgZvtaqz+vhLEVFsmTnyveHzfJbvkyWxESpfTspcayrQDzd3RFHj3btHzNGatxYuummassNAAAAAGeDcguAZzlyROrfX7riijMXWzt2SPePkVZ8qLyY5sq+5wblt2pCoXU6RYb8du2Tbd0WBQ4Z4pqd9dxzrvW1yjJqlJScLN1xhxQTI110UfXlBQAAAIAzYM0tAJ5l0iTJz0966y3XpXFlmTVLatNGBd9/K+eYQXLec4Py2kRTbJ2Jj0X5zS9U+m1/V+qDtyvfeVjq1EmaOFEqKir7uKQkV6k1cmT1ZQUAAACAs8DMLQCe49tvpVdekRYskByO0scUFroukZs1S1n9uynrys5ntx4XSihoeL6Oj75FgV9tVci0adIv26T5b0rBwSUH+/pKzz8vxcVJ774rXX999QcGAAAAgFLwGyEAzzFhgutOfTfeWPr+wkLp+gEyXn5JaXdep6yru1BsVYLcy2J1fNRAGZ9+IsXHS1lZpQ9s314aPFh68MHTz/ICAAAAgGrEb4UAPENysvTJJ67L48pa4HzcOGnVKjnvG6gTl7Sq3nw1XH6zC5Q6doiM7b9Ig24pu7x68EFp1y5p9erqDQgAAAAAZaDcAuAZFi+WIiOlK68sff9LL0lJSUof3Ff5zRpWb7ZaorBuuJzDBkgfrnSVjKVp3dq1Rtc771RvOAAAAAAoA+UWAM/w8cfSVVeVfpnhvn3SmNHKurqLcttzp76qlN+sodJvvkqaMkXasKH0QX37ur5fAAAAAOABKLcAeIatW11rOpVm7FgVhtiVfVWX6s1US+VeGqO8i5pK99xd+uWJHTpIe/dKTmf1hwMAAACAv6DcAmC+rCzp+HGpceOS+9atk955RxnX95Dha632aLVV5nU9pO9/kObPL7nz5Pfp99+rNRMAAAAAlIZyC4D5MjJcfzocJfc9M035zRspr0109Waq5Qqi6io37mJp2tSSO09+n9LTqzcUAAAAAJSCcguA+U5e+vbX9bacTmn5B8rpElv9maCcLm1ds7e+/774jpPfp7LuqAgAAAAA1YhyC4DnWr1aMgydiGHWlhnymzRQUViI9OGHZkcBAAAAgDJRbgHwXBs3qqBhPRm2QLOT1E4Wi/KbREmbN5udBAAAAADKRLkFwHPt2KGCOmFmp6jVCupFyEj+xewYAAAAAFAmyi0AHstwHpcRxKwtMxlBgdJxp9kxAAAAAKBMlFsAPJYlP1/ytZodo8plncjTpY8+r8Gz3zY7SklWqywF+WanAAAAAIAyUW4BgMkMQyoyDBUZhtlRAAAAAMDr+JodAABqO3ugvzY+NsLsGAAAAADglZi5BQAAAAAAAK/FzC0ANcbKrdt164uL3c+/fHS4/rv8c32evEfOrBxJ0rArOurlNZskSXHNGmr52KGSpE9/3q2bn1soSQoPtumXKfeXes7Nk+/V5KWfas3Pu+Xj46OOTRro8Rt6q3Hd8EoZ/1vSAwrw8y33eU7aceiYHl+6Rl9u36v8wkK1iqqrcX0v14ufbtQXyXskSbdcFqvpg/udwycNAAAAAJ6DmVsAaoyrY1vo8OyHdNXfWkiSxi9Yqdu6tdOWJ+7TygduldXHosSru+jw7IcU5O9X7NgeFzXV4dkPKfbCyNOe8+F3VuuuK+K09T+j9PIdCfoieY+Gv7K00sZX9DyS9GvKcfWbMk9bfzuoucMG6Oenx2jm0P56ac0m/bz/iPx9rTo8+yGKLQAAAAA1CuUWgBrrvj6ddVmLRrL5+6ld4ygdeG6iIuxB53TOwV3aqkPTBgry91O3Vk3Uu020tuw9qNTM7EoZfy6v++T7a5WWk6vHb+it7q2bKDjAXy3r19ULt1+r7DzueAgAAACgZqLcAlBjtWscVennbNuofrHnUeEhkqRDaZmVMv5cXvfTn3dJkq64qGmxsefZg9S83nnlej0AAAAA8BaUWwBqrL9eelgZQmwBxZ77+1olSUWGUSnjK/q6eQWFyszNU4Cfr4ID/EscHxoUWK7XAwAAAABvQbkFoFby8bEor6CwxPa0nBMmpDl3/r5W2QP9dSK/QFkn8krsP5pRvssgAQAAAMBbUG4BqJXqhdh1yJlRbNuR9CztT00zKdG563lxM0muOz+e6kh6lnYdOWZGJAAAAACocpRbAGql+Iua6lBapuau3aysE3nak3JcD7/zP9VxBJsdrcIe+nu8woJt+uc7q/XZtl+VdSJPvxxI0ejXl+v8ELvZ8QAAAACgSviaHQAAKss3v+5X3ynz3M8vHP20JOnw7IdKjH3wmu7KzS9Q0kdf6bElnyr2wvp67P96aU/KSm397ZDqjXhSI/t01tWxLUqcc8xVXTTx791Vb8ST7u09n5yr3m2idf/VXco1flCXtrr1xcXFxl8f10Z3dG9frvPMH3GjGtcN14fj/6HJSz7VHS+/p4KiIrVpWE+TEuL19Adf6Fg579AIAAAAAN6AcgtAjdG+SYNSi6zShNgC9MygviW2/+/B20tsK+ucnrZdkpqdH6HXhv9fie1H0jIVYbeVeRwAAAAAeCsuSwSAGuJIepZajntG+YVFxbbvO5amPSnHdXmLxuYEAwAAAIAqRLkFwLMZhtkJvIozO1fjF3yoA8fTlZOXr+/2HNCwuUtktwUosW9Xs+MBAAAAQKXjskQAnivYLmWnmJ3Ca5wfEqzFo2/RK599o78/84YOpWUqLChQ3Vo10Qu3XatGdcLKfU7LiTwZwcGyVEFeAAAAAKgMlFsAPFdkpKxb9pidwqtc3rKxLm/ZuNLO55OeJUu9epV2PgAAAACobFyWCMBzXXyxfPczc8tMvgeOSjF/MzsGAAAAAJSJcguA5+rWTT6pTvkePGp2klrJkntCfrt/l7p1MzsKAAAAAJSJcguA54qLk+qdr4DNP5mdpFYK+C5Z8vGRrr7a7CgAAAAAUCbKLQDm8/d3/ZmfX3y71SoNu0u2r3+Q5URe9eeqzQxDQZ99Kw0YIEVEFN+X98f34uT3DQAAAABMRLkFwHyhoa4ZQqmpJffdf798LFYFr/qq+nPVYravtsp3/2HpoYdK7jz5ffpr6QUAAAAAJqDcAmA+Pz+pSRPp559L7ouIkP79bwV9slHWI6WUX6h0ltwTCl6xTho1SoqJKTlg2zYpIEBq1Kj6wwEAAADAX1BuAfAMcXHS55+Xvu+ee6RWLRU67wNZ8guqN1dtYxgKeWOFfPwCpEceKX3M559Lbdu6SkkAAAAAMBnlFgDP0LevqzQ5dqzkPl9fadly+abnKGTecskwqj9fLWFfulYBP+6S3n5bCgsrOaCgQFq2TOrXr/rDAQAAAEApKLcAeIaEBMlmk155pfT9TZpI776rgB92yvH2/6QiCq7KFrR6vYI+Xu/6HsTHlz5o6VLpyBFpyJBqzQYAAAAAZaHcAuAZ7Hbp7rul//639IXlJal7d+mtt2Tb8JPCXlwsSy53UKwUhUVyLFgp+/trpenTpcGDSx+Xny/985/S9ddLjRtXZ0IAAAAAKBPlFgDPMWmSa6HystZ6klzFymefyf9wmiKmvSG/nfuqL18N5HswReHPviXbd8muWVmjR5c9OClJ2rtXevrp6gsIAAAAAGdAuQXAczgc0pNPSi+8IH3xRdnj4uKkzZtlvfhvCp8+X6GvLpM1Na36ctYAPpnZcry9WhFPviI/Rx3pq6+la64p+4Dt26XJk6Xx45m1BQAAAMCj+JodAACKGTrUtWD5gAHS+vVSs2alj7vgAumj/0nLlytgzGgFPPK88tpEK7dtC+U3v1CFEWGSpXqjezofZ4b8dv2ugB92KHBLshQaJr30knTrrZLPaf5fR2qq1L+/1Lq1NHFiteUFAAAAgLNBuQXAs1gs0htvSN26uWYSffaZVLdu2eOvuUa68kpp6VL5v/qK/Betlk6ckBHgL8MeLPlaqy+7pyoskiUzW5bcXMlqlS67TJo1W7r5Zik4+PTHZme7LgXNy3NdthgYWD2ZAQAAAOAsUW4B8DxBQa7ZW5dfLl16qbR8uXTRRWWP9/eXbrzR9cjOlr7/XpZt22RxOl2lTG1ntUrh4VJ0tNS2rRQaenbHHTggXXuttGeP9MknUmRklcYEAAAAgIqg3ALgmaKiXJclDhjgmmk0b56raDmToCBXIXbppVWfsSb7+mtXWWi3n/7yUAAAAAAwGQvKA/BcdetKH3/suiwuIcG17tP27WanqtkOHpT+8Q+pSxfpb39zlVwUWwAAAAA8GOUWAM8WECDNnSutWSPt2yfFxLjKl88+kwoLzU5XMxiGtHmzdN99UsuW0uefS++8I61YIYWFmZ0OAAAAAE6LyxIBeIf4eOnbb12XJz73nOt5WJjUvr3UtKlrTSkLt0csF6dT2rtX+u476fBhqXlz6V//ku65R7LZzE4HAAAAAGeFcguA97Bapdtvdz127JBWrZK2bpV+/dVV0BiG2Qm9S2ioa22zceOkXr1ci80DAAAAgJeh3ALgnZo3dz0AAAAAALUaa24BAAAAAADAa1FuAQAAAAAAwGtRbgEAAAAAAMBrUW4BAAAAAADAa1FuAQAAAAAAwGtRbgEAAAAAAMBrUW4BAAAAAADAa1FuAQAAAAAAwGv5mh0A8GQpKSlq2rSp2TEAr3bgwAG1a9fO7BgAAAAAaijKLaAMXbp00eOPP252DKBG6NChg9kRAAAAANRQFsMwDLNDAAAAAAAAABVwkDW3AAAAAAAA4LUotwAAAAAAAOC1KLcAAAAAAADgtSi3AAAAAAAA4LUotwAAAAAAAOC1KLcAAAAAAADgtSi3AAAAAAAA4LUotwAAAAAAAOC1KLcAAAAAAADgtSi3AAAAAAAA4LUotwAAAAAAAOC1KLcAAAAAAADgtSi3AAAAAAAA4LUotwAAAAAAAOC1KLcAAAAAAADgtSi3AABAtcjMzJTFYin2+Prrr8943Pjx44sd8/jjj1dD2uIWLlzofv3AwMAzjvfm9woAAOBtLIZhGGaHAAAAtceWLVt0ySWXSJKuvvpqffjhh2WOPXbsmBo3bqzMzEwNGjRI8+fPr66YperVq5fWrVun3Nzcsxrvre81MzNTl1xyiVq2bKkPPvjAtBwAAABn4SAztwAAQLWz2Wxq1KiRVq5cqc2bN5c5bvr06brggguqMVnlM+O92u12de3atcLHG4ahoqIiFRUVVUoeAACAqkS5BQAAqp2Pj48efPBBSSrz0jun06nnn39eEyZMqM5olc4b36vD4dCuXbtOO9MMAADAU1BuAQAAU9x2221q0KCBli1bpu+//77E/pkzZ6pv375q1qyZCekqV216rwAAANWNcgsAAJgiICBA48ePl2EYeuKJJ4rty8zM1LPPPquHHnrotOc4duyYEhMT1axZM/n7+ys8PFxXX3211qxZc05jf/nlFyUkJCg0NFTBwcG6/PLLtW7dOtPea0FBgRYtWqTevXsrMjJSNptNMTExSkpKKnbp4NSpU2WxWJSVlaUvv/zSvTC9r6+vJGnp0qXFFqxPTk7WjTfeqPPOO8+9bc6cOcXGnFxfrGvXrsW2Dx48WJJrHbJTtzudzgp/TgAAABVBuQUAAExz1113qV69elq8eLG2bdvm3j5r1iz16NFDrVu3LvPYQ4cOqWPHjlqwYIGSkpJ09OhRbdiwQUFBQerZs6fmzJlTobE7d+5U586dtXnzZi1evFiHDx/W7NmzNXnyZO3atcuU97pq1SoNHDhQPXr00LZt27Rv3z7dddddSkxMLHYp47hx42QYhoKDg9WlSxcZhiHDMFRQUCBJSkhIkGEYuvbaayVJw4cP14gRI7Rv3z6tX79eVqu1xJiT1q1bpy1btig4OFixsbF68cUXJUkrVqxQp06d9NZbb8kwDIWFhVX4MwIAAKgIyi0AAGAam82mxMREFRUV6cknn5QkZWdna/r06Zo0adJpj504caJ+/fVXzZgxQ/3791dISIhatGihBQsWqH79+ho1apQOHz5c7rEPPfSQnE6nkpKS1Lt3b9ntdsXExOjVV1/VwYMHTXmvkhQfH6+JEycqPDxcderU0ciRI3XLLbcoKSlJ6enpFco0YcIExcfHKygoSJ06dVJBQYHq1KlT5vjY2Fi9+uqr2rp1q4YOHSrDMDR8+HD17NlTAwcOrFAGAACAc0W5BQAATDVixAidd955euutt7Rz5069+OKLuvTSS/W3v/3ttMctWbJEktSvX79i2wMCAtSzZ0/l5OToo48+KvfYVatWSZKuvPLKYmOjoqLUokWLCr5Ll4q+1/79+5d6+WRsbKzy8/P1008/VShPXFxcuY+54YYbNGnSJL333nvq2rWrjh07psmTJ1fo9QEAACoD5RYAADCV3W7XmDFjVFhYqEcffVRTp07Vww8/fNpjTpw4obS0NAUGBsrhcJTYX69ePUmuyxHLOzYjc+aK4wAAA5tJREFUI0OBgYGy2+0lxp5//vkVeYtuFXmvkpSWlqZHHnlEMTExCg8Pd69vNX78eEmuGWAVERwcXKHjJk+erE6dOumrr77SDTfcIB8f/pMSAACYh/8SAQAAphs5cqRCQ0O1YMECxcbGqkOHDqcdHxAQoNDQUOXm5iojI6PE/pOXGEZGRpZ7rMPhUG5urjIzM0uMTU1NrcjbK6a871WSrrnmGk2ePFnDhg3T9u3bVVRUJMMwNH36dEmSYRjFxlsslnPOeTpr165VWlqaYmJiNGLECG3durVKXw8AAOB0KLcAAIDpQkNDlZj4/+3cwSttaxgH4PemPdgUpcREMVKGZKKUMpARyggDZWCgtDsjIxPFwISk5G8gJTPJSP4AJQwYKNTeA2WXkL47uJ193Uuns3Pu6a56nlqDtda7vvW901/rXd+ioaHhp75kiogYHR2NiL9+aP7e8/NzHB4eRj6fr4wWVlM7NDQUEX+PJ35XKpXi4uKiys4+qrbXt7e3OD4+jpaWlpibm4umpqZKePX09PTpM7W1tfHy8lI57+joiK2trS/vPSLi+vo6pqenY2dnJ/b29iKfz8fw8HAUi8Vfsj4AQLWEWwDA/8LCwkI8PDxEb2/vT9UvLy9He3t7FAqF2N/fj8fHx7i8vIzx8fG4u7uLtbW1yshhNbVLS0vR2NgYhUIhDg4Oolwux9nZWUxOTn46qvhf91pTUxP9/f1xf38fKysrUSqV4unpKY6OjmJzc/PTZ7q6uuLy8jJubm7i5OQkrq6uoq+v78v7LpfLMTIyEqurq9HZ2RltbW2xvb0dt7e3MTY2Fq+vr19+BwBA1RIAwG9SV1eXIqJyDA4O/rD+fe33Y319vXK/VCqlQqGQ2tvbUy6XSw0NDWlwcDAdHh5+WKua2ouLizQyMpLq6+tTPp9PPT09aX9/Pw0MDFT2MT09/dt6LRaLaWZmJrW2tqZcLpeam5vT1NRUmp+fr9R2d3dX1jo/P099fX2prq4utba2po2NjZRSSicnJ5++573d3d0P9ycmJtLs7Ow/rp2enqZisfihdnFx8Yd9AgD8Yrd/pPSvnzQAAAAAQDbcGUsEAAAAILOEWwAAAABklnALAAAAgMwSbgEAAACQWcItAAAAADJLuAUAAABAZgm3AAAAAMgs4RYAAAAAmSXcAgAAACCzhFsAAAAAZJZwCwAAAIDMEm4BAAAAkFnCLQAAAAAyS7gFAAAAQGb9Cchn52Q9yghiAAAAAElFTkSuQmCC\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": "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\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": "iVBORw0KGgoAAAANSUhEUgAABK8AAAKHCAYAAABHK2uFAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzde1TVVf7/8ecB5I7cFMnRlCgvEWEXNCYpEskbBjmmZIw1hdrXUBmXjWFO40hlTlqebJxsWtk4U6mZYmlpappp4K3SIVPSg7cEFQkCBQT5/P7ox5kQLBDwHPD1WOusFvvsz97vz3GJ8WLv/TEZhmEgIiIiIiIiIiJif9Y52LoCERERERERERGRS1F4JSIiIiIiIiIidkvhlYiIiIiIiIiI2C2FVyIiIiIiIiIiYrcUXomIiIiIiIiIiN1SeCUiIiIiIiIiInZL4ZWIiIiIiIiIiNgthVciIiIiIiIiImK3FF6JiIiIiIiIiIjdUnglIiIiIiIiIiJ2S+GViIiIiIiIiIjYLYVXIiIiIiIiIiJitxReiYiIiIiIiIiI3VJ4JSIiIiIiIiIidsvJ1gWI2Mprr73Gxo0bbV2GyFUjLCyM6dOn27oMERERERFpYbTySq5au3bt4vPPP7d1GSJXhd27d7NlyxZblyEiIiIiIi2QVl7JVe3mm2/mvffes3UZIq1eUlISR48etXUZIiIiIiLSAmnllYiIiIiIiIiI2C2FVyIiIiIiIiIiYrcUXomIiIiIiIiIiN1SeCUiIiIiIiIiInZL4ZWINMry5cu55ZZbcHd3x2QyYTKZyMrKIi8vj9///vd07NjR2p6YmGjrcm1uyZIl1s/D1dXV1uWIiIiIiIjYPYVXInLZMjIyGDFiBDExMZw6dYqDBw/SqVMnAEaNGsWmTZtYt24dP/74I08++WSDxy8pKeGGG24gNja2qUu3mYSEBAzDIDo62taliIiIiIiItAhOti5ARFqupUuXYhgGkyZNwtPTE09PT44dO0Z+fj6bNm3iiSeeIDQ0FIDZs2djGEaDxjcMg6qqKqqqqpqj/Evy9PSkV69ebN269YrOKyIiIiIiIrUpvBKRy3bs2DEA/P39f7W9eqtcQ3h5eXHo0KFGVikiIiIiIiItmbYNishlu3Dhwi+2NzSsEhEREREREbmYwiuRq8CZM2eYPHkywcHBuLi40KlTJ/r3789bb71FaWmptV9lZSVLly4lJiaGwMBA3NzcCA0NxWw219i6l56ejslkYtWqVQC4ublZV1aZTCbCw8MB+Otf/2pt27x5s/X606dPM3HiRLp27YqzszPt27dn2LBhfP3117XmqH6VlZXV2X748GFGjhyJj48P/v7+xMbG1lqtVd/7mjNnDiaTibNnz7Jt2zbrHE5ONRep1qf+avv37yc+Ph5vb288PDyIjIzUdkQREREREZEGUHgl0srl5eURHh7Ou+++i9lsJj8/n927dxMVFcUf/vAHFi5caO27du1aEhIS6NevH99++y3Hjh1j7NixTJ48malTp1r7xcfHYxgGcXFxAJSWllJVVcWFCxeorKwkMzMTgD//+c9UVFRQUVHB3XffDUBubi7h4eEsW7aMBQsWUFBQwObNmykoKCAiIoKMjIw657jU3CkpKaSkpPD999+zdOlSPv30Ux588MEa19T3vqZMmYJhGHh4eHDnnXdiGAaGYVBZWWntU9/6AQ4ePEhERAS7du1i+fLlnDx5kgULFpCWlqbtkCIiIiIiIvWk8EqklUtNTSUnJwez2UxsbCxeXl506NCB6dOnM3DgwFr9o6KiSE1NxdfXl3bt2jFhwgRGjRqF2Wzmxx9/vOQ8JpMJBwcHHB0dcXR0BMDBwQEnJyecnJysWwhTU1M5cuQIL730EoMHD8bT05OQkBCWLFmCYRhMmDChQfeXlJREREQEHh4e9O/fnyFDhrBz507y8/Ob5L4u1pD6p02bRmFhIWazmZiYGDw9PQkNDWXRokXk5uY26D5FRERERESuVgqvRFq5lStXAjBo0KBa73388cekpKRYv46NjWXTpk21+oWFhVFRUcE333zT6HrS09NxcHAgNja2RntgYCAhISHs3r2b48eP13u86i2K1Tp37gzAiRMnrG1NeV8NqX/t2rUADBgwoEbfjh070q1bt3rPKSIiIiIicjXT0wZFWrHy8nKKiopwdXXFy8vrV/sXFRUxd+5cVq5cyfHjxyksLKzx/rlz55qkHgBvb+9L9vvuu+/o1KlTvca8eBxnZ2eAGmdZNdV9NaT+9u3bU1xcjKurK56enrX6BAQEkJ2dXa95RURERERErmZaeSXSirm4uODt7U1ZWRnFxcW/2n/o0KGkpaUxZswYsrOzqaqqwjAMXn75ZQAMw2h0PT4+Pjg5OVFRUWE9U+ri1z333NOoeS7W0Pu61FMSG1K/i4sLXl5elJWVUVJSUmusgoKCJr1HERERERGR1krhlUgrd//99wPw0Ucf1Xrvlltu4Y9//CMAFy5cYNu2bQQGBjJx4kTat29vDXF+/kTCxho2bBiVlZVs27at1nuzZ8/m2muvrXFAemNdzn25u7tz/vx569fdu3fn9ddfb3D91Vs1q7cPVsvPz+fAgQONvzkREREREZGrgMIrkVZu1qxZBAUF8cc//pE1a9ZQXFzM8ePHGT9+PLm5udbwytHRkaioKPLy8njxxRfJz8+ntLSUTZs28dprrzVpPcHBwTz66KN8/PHHFBUVUVBQwMKFC5k5cyZz5szByanpdjRfzn3deuutZGdnc+zYMTIyMrBYLERGRja4/ueffx4/Pz9SUlJYv349JSUl7Nu3j8TExDq3EoqIiIiIiEgdDJGr1GOPPWbExMTYuowrIj8/30hJSTGCgoKMNm3aGNdcc42RkJBgZGdn1+h3+vRpY9y4cUbnzp2NNm3aGB06dDAeeeQR46mnnjIAAzBuu+02Y+XKldavf/7KyMgwQkJCDEdHRwMwTCaT4ejoaAwbNqzGPGfOnDEmT55sXHfddUabNm2M9u3bG/fee6+xfv16a5+65njooYeMjIyMWu1PP/20YRhGrfYhQ4Y06L6q7d+/34iMjDQ8PDyMzp07G3//+98bXH+1AwcOGPHx8Ubbtm0NNzc3Izw83Fi9erURHR1tnfuxxx5r3B9wC3A1/X0TEREREZEmtdZkGI08xEakhUpKSuLo0aN88sknti5FpNXT3zcREREREblM67RtUERERERERERE7JbCKxERERERERERsVsKr0RERERERERExG4pvBIREREREREREbul8EpEREREREREROyWwisREREREREREbFbCq9ERERERERERMRuKbwSkSvK09OTvn372roMERERERERaSEUXomIiIiIiIiIiN1ysnUBIiIiItL6/Pjjj5w8eZIff/zR1qW0CJ6engQEBODr62vrUkREROyOwisRqeX06dOkpaXxwQcfcOLECby9vYmMjOSZZ56hV69eAKSnp3P//fdbr8nJyWHq1KmsW7cOR0dHIiIiMJvNBAcHAzBnzhyefPJJALZt24bJZALA0dGRysrKRs29f/9+/vznP7Nx40YKCgqs47Rr164ZPyUREfm5qqoqPvnkE1asWMHGjRvJycnBMAxbl9XidOrUiXvuuYf4+HiGDh1KmzZtbF2SiIiIzZkM/V+FXKWSkpI4evQon3zyia1LsSu5ublERERQVlbGm2++yV133cWRI0d44okn2L59O59++ikRERHW/vHx8axatYq4uDimTp3KzTffTEZGBvfddx833XQTO3bsqDG+p6cnvXr1YuvWrU029913382MGTPo3bs3//3vf7nzzjvJy8ujXbt29OvXjz179rBmzRruuOOO5vvg5Bfp75tI67Zs2TKmTZuGxWIhPDycQYMGcdttt9G5c2fatm1r6/JahJKSEnJzc9m9ezfr16/n888/JyAggL/85S8kJSXh6Oho6xJFRERsZZ1WXolIDampqRw5coS3336bwYMHAxASEsKSJUvo2rUrEyZMYNeuXbWuS0pKsgZL/fv3Z8iQISxfvpz8/Px6r4C63LmnTp1KVFQUAH369KmxkquqqgrDMPTbfxGRZvDf//6XiRMnsmXLFkaPHs3q1avp0aOHrctqsW6++WYGDBjAtGnTOHLkCPPmzWPChAksXLiQV155RQ88ERGRq5YObBdpxbKysjCZTDVeycnJv3hNeno6Dg4OxMbG1mgPDAwkJCSE3bt3c/z48VrXhYeH1/i6c+fOAJw4caLe9V7u3L17977kmJs3b6agoKDGii0REWm8JUuW0Lt3b8rKysjMzGTRokUKrppQly5dePnll9m7dy8BAQFERUUxb948W5clIiJiE1p5JdKK3XTTTQ1acVReXk5RUREA3t7el+z33Xff0alTpxptF/d3dnYGflr51Nxze3h41GsOERFpPMMw+Nvf/sa0adNITk7mpZde0pa2ZtSjRw/Wrl2L2Wxm8uTJfPPNNyxYsEBnYYmIyFVF4ZWIWLm4uODj40NJSQmlpaU4OTX9t4jqg9ptMbeIiDTeX/7yF1544QX+8Y9/MHbsWFuXc9WYNGkSXbt25aGHHqKyspJFixbZuiQREZErRtsGRaSGYcOGUVlZybZt22q9N3v2bK699toaZ0o1lLu7O+fPn7d+3b17d15//fUrMreIiDTOsmXLePbZZ5k/f76CKxuIi4vj/fff5z//+Q+zZ8+2dTkiIiJXjMIrEalh1qxZBAcH8+ijj/Lxxx9TVFREQUEBCxcuZObMmcyZM6dRq6JuvfVWsrOzOXbsGBkZGVgsFiIjI5tt7n79+uHv709mZuZl1ywiIvDll1/y8MMPM2XKFMaNG2frcprckiVLrOdDurq62rqcSxowYAAvvfQS06ZN4+OPP7Z1OSIiIleEwisRqSEgIIAdO3YQHx9PcnIy7du3p0ePHqxYsYJVq1YxYsQIADIzMzGZTKxatQoANzc3pk+fDvy0NbD6N8K33HJLjQPY582bx80330zPnj0ZOXIkZrOZnj17NnruS21HrKys1NMGRUQayTAMnnjiCXr37s0LL7xg63KaRUJCAoZhEB0dXeu9kpISbrjhhloPFLGVCRMmMHLkSJKTkykrK7N1OSIiIs3OZOgnOrlKJSUlcfToUT755BNblyLS6unvm0jL9q9//YvHHnuM3bt3ExYW1mTjenp60qtXL7Zu3dpkYzZW//792bp1a41QqLi4mF69etG9e3c++ugjG1b3P3l5eXTv3p0//elPPP3007YuR0REpDmt08orEREREbmkiooKpk+fztixY5s0uGpJvLy8OHTokN0EVwCBgYE89dRTzJo1ix9++MHW5YiIiDQrhVciIiIickkffPABubm5TJ061dalyEWSk5NxcHBg8eLFti5FRESkWSm8EhEREZFLWr58Offccw9dunSpV//y8nKeeeYZevTogbu7O35+fgwdOpQPPviACxcuADBnzhxMJhNnz55l27Zt1oPSf/5QjsrKSpYuXUpMTAyBgYG4ubkRGhqK2WymqqrK2i89Pd16vclk4vDhw4wcORIfHx/8/f2JjY3l0KFDtercv38/8fHxeHt74+HhQWRkZJ3bFy8ev3o7YVPM6+7uTu/evVm9ejX9+/e3jpWUlFSvz9rLy4vf/e53vPfee/XqLyIi0lIpvBIRERGRS9qwYQODBg2qd//k5GReeeUV5s+fz5kzZ/j222/p0aMHcXFxfP755wBMmTIFwzDw8PDgzjvvtD5Yo7Ky0jrO2rVrSUhIoF+/fnz77bccO3aMsWPHMnny5BqrwOLj4zEMg7i4OABSUlJISUnh+++/Z+nSpXz66ac8+OCDNWo8ePAgERER7Nq1i+XLl3Py5EkWLFhAWlparcDp4vGbct5Tp06xaNEizGYze/fuxcXFBcMweOONN+r9eQ8ePJjMzExKSkrqfY2IiEhLo/BKREREROp07Ngx8vPzuf322+t9zcaNGwkJCSEmJgY3Nzc6dOjAiy++SLdu3Ro8f1RUFKmpqfj6+tKuXTsmTJjAqFGjMJvN/Pjjj3Vek5SUREREBB4eHvTv358hQ4awc+dO8vPzrX2mTZtGYWEhZrOZmJgYPD09CQ0NZdGiReTm5ja4zsbMGxISwjvvvMPZs2cva97bb7+dCxcukJWVdVnXi4iItAQKr0SkRVqyZIl1e4Wrq6utyxERaZW+//57ALp27VrvawYOHMgXX3zB2LFjyczMtG4VPHDgAFFRUfUeJzY2lk2bNtVqDwsLo6Kigm+++abO68LDw2t83blzZwBOnDhhbVu7di0AAwYMqNG3Y8eOlxWyNXbe9u3b06NHj8uat0uXLphMJo4fP35Z14uIiLQECq9EpNndcccdxMbGNumYCQkJGIZBdHR0k44rIiL/U1xcDPx0tlJ9/f3vf2fx4sVYLBaio6Np27YtAwcOZOXKlQ2au6ioiGeeeYbQ0FB8fX2tv7B48sknATh37lyd13l7e9f42tnZGcB6TlZ5eTnFxcW4urri6elZ6/qAgIAG1dlU8/r6+l7WvA4ODnh4eFxyJZqIiEhroPBKREREROpUHbw4ONT/fxlNJhO///3v2bBhA4WFhaSnp2MYBsOGDeOll16q1fdShg4dSlpaGmPGjCE7O5uqqioMw+Dll18GwDCMy7gjcHFxwcvLi7KysjrPiSooKLiscRs776lTpy57bAcHhxqH2IuIiLQ2Cq9EREREpMn4+Piwf/9+ANq0aUNMTIz1yXxr1qyp0dfd3Z3z589bv+7evTuvv/46Fy5cYNu2bQQGBjJx4kTat29vDbpKS0sbXWP1AfTV2/iq5efnc+DAgUaP39B58/LyyM7ObrZ5RUREWjqFVyIiIiLSpB5//HH27t1LeXk5p06d4m9/+xuGYdCvX78a/W699Vays7M5duwYGRkZWCwWIiMjcXR0JCoqiry8PF588UXy8/MpLS1l06ZNvPbaa42u7/nnn8fPz4+UlBTWr19PSUkJ+/btIzExsc4tfU2lrnmzsrL4wx/+QGBgYLPNKyIi0tIpvBKRFmH//v3Ex8fj7e2Nh4cHkZGRbN269ZL9z5w5w+TJkwkODsbZ2RlfX18GDRpU5+G/v6Zv377Ws1ZMJhOJiYkA9O/fv0Z7YWHhZd+fiEhr8dlnn9GjRw8SEhLw8/OjZ8+erF27ln/+859MmzatRt958+Zx880307NnT0aOHInZbKZnz54ALF26lHHjxjF//nw6duxIUFAQixcvZtSoUQDExMRw++23k5mZiclkYtWqVQC4ubkxffp04KdtibNnzwbglltusZ6/GBwcTEZGBuHh4QwfPpyAgAAeeeQRJkyYQGhoKOXl5ZhMJpKSkqyrxn4+fmJiYpPM26FDB8aNG0dqaipBQUE4Ojo2zx+KiIhIC+dk6wJERH7NwYMHrY8fX758OREREeTk5DBlyhQOHTpUq39eXh6//e1vOXfuHG+88QZ33XUXeXl5pKamEh0dzeuvv05SUlK959+6dSt79uzhzjvv5Prrr2fhwoUArFmzhrvvvpuUlBQSEhKa7H5FRFqysLCweq+O6t69O1u2bKnzvXbt2l1ynFmzZtX4+lLnX/3SuVjdunWr8xD5IUOG1Hucppw3NzeXdu3aXfI6ERGRq5lWXolIk3JycqqxGslkMrF9+3bWrFlTq72+WySmTZtGYWEhZrOZmJgYPD09CQ0NZdGiReTm5tbqn5qaSk5ODvPmzSM2Npa2bdvSrVs33nnnHa655homTpzIyZMnG3RfYWFhLFq0iD179jB69GgMw2DcuHFER0cruBIRkXrJy8vDz8+PioqKGu2HDx/m0KFDtbZVioiIyE8UXolIk6qsrMQwjBqvPn36MGTIkFrteXl59Rqz+mDbAQMG1Gjv2LEj3bp1q9W/+jfaF//23MXFhejoaEpLS1m3bl2D7+2BBx7g6aefZsWKFfTt25czZ86QlpbW4HFEROTq9cMPPzBu3DiOHTvGuXPn2LFjByNHjqRt27b8+c9/tnV5IiIidknhlYjYtfLycoqLi3F1da3zEN2AgIBa/YuKinB1dcXLy6tW/w4dOgDUOzi7WFpaGn369OGLL77ggQceaNDj40VE5OoWGBjIhg0bKCws5K677sLX15f77ruPG264gR07dnDdddfZukQRERG7pDOvRMSuubi44OXlRXFxMSUlJbUCrIKCglr9vb29KSoqori4uFaAVb1d8HKf6rR582aKiooIDQ1l/PjxhIWFERYWdlljiYjI1Sc6Opro6GhblyEiItKiaMmAiNi9QYMGAf/bPlgtPz+fAwcO1Op///33Az8dqP5z5eXlbNy4ETc3t1pbEOsjJyeHxx57jPfff58PPvgANzc34uLiOH36dIPHEhERERERkfpReCUidu/555/Hz8+PlJQU1q9fT0lJCfv27SMxMbHOrYSzZs0iKCiIlJQUVq9eTXFxMdnZ2YwaNYrc3FzMZrN1+2B9lZSUEB8fz7x587jxxhvp2rUry5cv58SJEwwfPrzW4bsiIiIiIiLSNBReiYjdCw4OJiMjg/DwcIYPH05AQACPPPIIEyZMIDQ0lPLyckwmE0lJScBPWwJ37tzJgw8+yMSJE/H396d3796cPXuWDRs2MGbMmAbNn5ycjJeXF3v37iUuLo6srCzy8/OJioqioqKCLVu24OzszLPPPtscty8iIiIiInJV05lXItLsMjMzGz1Gt27drE8R/LmLnyhYzd/fn5dffpmXX3650XO/+uqrvPrqq7XaDcNo9NgiItK8PD096dWrF1u3brV1KSIiInKZtPJKRERERERERETslsIrERERERERERGxWwqvROSqZTKZfvU1Y8YMW5cpItLqnT59mokTJ9K1a1ecnZ1p3749w4YN4+uvv7b2SU9Pr/H9+fDhw4wcORIfHx/8/f2JjY3l0KFD1v5z5szBZDJx9uxZtm3bZr3Oycmp0XMfOHCAESNG4O/vb23Lz89v/g9KRETkKqXwSkSuWoZh/OpL4ZWISPPKzc0lPDycZcuWsWDBAgoKCti8eTMFBQVERESQkZEBQHx8PIZhEBcXB0BKSgopKSl8//33LF26lE8//ZQHH3zQOu6UKVMwDAMPDw/uvPNO6/f1ysrKRs89btw4xo8fz7Fjx8jMzMTR0dE6Zr9+/fD392+S8x5FRETkJwqvRERERMRmUlNTOXLkCC+99BKDBw/G09OTkJAQlixZgmEYTJgwoc7rkpKSiIiIwMPDg/79+zNkyBB27tzZoBVQlzv31KlTiYqKwt3dnT59+lBZWUm7du0AqKqqsgZlIiIi0jQUXomIiIhIk8jKyqq1/To5OfkXr0lPT8fBwYHY2Nga7YGBgYSEhLB7926OHz9e67rw8PAaX3fu3BmAEydO1Lvey527d+/elxzz5yu3REREpGk4/XoXEREREZFfd9NNNzVoxVF5eTlFRUUAeHt7X7Lfd999R6dOnWq0Xdzf2dkZ+GnlU3PP7eHhUa85REREpGkovBIRERERm3BxccHHx4eSkhJKS0trHabeFEwmk83mFhERkaahbYMiIiIiYjPDhg2jsrKSbdu21Xpv9uzZXHvttTUOWW8od3d3zp8/b/26e/fuvP7661dkbhEREWkaCq9ERERExGZmzZpFcHAwjz76KB9//DFFRUUUFBSwcOFCZs6cyZw5cxq1KurWW28lOzubY8eOkZGRgcViITIystnm1tMGRUREmp7WR4uIiIiIzQQEBLBjxw6ee+45kpOTOXbsGD4+Ptxyyy2sWrWK/v37A5CZmVnjEHQ3Nzeefvppnn322RpbA2+55RaGDBnC6tWrAZg3bx5jxoyhZ8+e+Pn5YTab6dmzZ6PnBuo836uyslJPGxQREWliCq9ERERExKb8/PyYO3cuc+fOvWSfO+6445KB0C8FRd27d2fLli3NNvfFfmkuERERuTzaNigiIiIiIiIiInZL4ZWIiIiIiIiIiNgthVciIiIiIiIiImK3FF6JiIiIiIiIiIjdUnglIiIiIiIiIiJ2S+GViIiISAsxZ84cTCYTJpOJTp062bqcFmfJkiXWz8/V1dXW5YiIiEg9KbwSERERaSGmTJmCYRiEhYXZupRmd8cddxAbG9ukYyYkJGAYBtHR0U06roiIiDQvhVciIiIiIiIiImK3FF6JiIiIiIiIiIjdUnglIiIiIiIiIiJ2S+GViIiISDNJT0+3HhBuMpk4cOAAI0aMwN/f39qWn58PwOnTp5k4cSJdu3bF2dmZ9u3bM2zYML7++ut6zVVZWcnSpUuJiYkhMDAQNzc3QkNDMZvNVFVVWfv17du3Rk2JiYkA9O/fv0Z7YWFh038gV9j+/fuJj4/H29sbDw8PIiMj2bp16yX7nzlzhsmTJxMcHIyzszO+vr4MGjSITZs2NXjuq+lzFhERaW4Kr0RERESaSXx8PIZhEBcXB8C4ceMYP348x44dIzMzE0dHRwByc3MJDw9n2bJlLFiwgIKCAjZv3kxBQQERERFkZGT86lxr164lISGBfv368e2333Ls2DHGjh3L5MmTmTp1qrXf1q1b+frrr/Hw8CAsLIyFCxcCsGbNGvr06cO7776LYRj4+Pg0wydy5Rw8eJCIiAh27drF8uXLOXnyJAsWLCAtLY1Dhw7V6p+Xl0d4eDjvvPMOZrOZ/Px8tm/fjru7O9HR0bzxxhsNmv9q+ZxFRESuBIVXIiIiIlfI1KlTiYqKwt3dnT59+lBZWUm7du1ITU3lyJEjvPTSSwwePBhPT09CQkJYsmQJhmEwYcKEeo0fFRVFamoqvr6+tGvXjgkTJjBq1CjMZjM//vijtV9YWBiLFi1iz549jB49GsMwGDduHNHR0SQkJDTX7V+Sk5NTjdVIJpOJ7du3s2bNmlrtgYGB9Rpz2rRpFBYWYjabiYmJwdPTk9DQUBYtWkRubm6t/qmpqeTk5DBv3jxiY2Np27Yt3bp145133uGaa65h4sSJnDx5skH3ZW+fs4iISEul8EpERETkCundu3ed7enp6Tg4OBAbG1ujPTAwkJCQEHbv3s3x48d/cezY2Ng6t7eFhYVRUVHBN998U6P9gQce4Omnn2bFihX07QrOGy8AACAASURBVNuXM2fOkJaW1sA7ahqVlZUYhlHj1adPH4YMGVKrPS8vr15jrl27FoABAwbUaO/YsSPdunWr1X/lypUADBkypEa7i4sL0dHRlJaWsm7dugbfmz19ziIiIi2Vk60LEBEREblaeHh41GorLy+nqKgIAG9v70te+91339GpU6dLvl9UVMTcuXNZuXIlx48fr3WW0rlz52pdk5aWxoYNG/jiiy/417/+hYND6/i9Znl5OcXFxbi6uuLp6Vnr/YCAALKzs2v0LyoqwtXVFS8vr1r9O3ToAFDv4OxirfVzFhERuVL0L6eIiIiIDbm4uODj44OTkxMVFRW1VhpVv+65555fHGfo0KGkpaUxZswYsrOzqaqqwjAMXn75ZQAMw6h1zebNmykqKiI0NJTx48ezZ8+eZrnHK83FxQUvLy/KysooKSmp9X5BQUGt/t7e3pSVlVFcXFyrf/V2wfpuWbxYa/2cRURErhSFVyIiIiI2NmzYMCorK9m2bVut92bPns21115LZWXlJa+/cOEC27ZtIzAwkIkTJ9K+fXtMJhMApaWldV6Tk5PDY489xvvvv88HH3yAm5sbcXFxnD59umluysYGDRoE/G/7YLX8/HwOHDhQq//9998P/HSg+s+Vl5ezceNG3Nzcam1BrI/W/jmLiIhcCQqvRERERGxs1qxZBAcH8+ijj/Lxxx9TVFREQUEBCxcuZObMmcyZMwcnp0uf9uDo6EhUVBR5eXm8+OKL5OfnU1payqZNm3jttddq9S8pKSE+Pp558+Zx44030rVrV5YvX86JEycYPnw4FRUVzXm7V8Tzzz+Pn58fKSkprF+/npKSEvbt20diYmKdWwlnzZpFUFAQKSkprF69muLiYrKzsxk1ahS5ubmYzWbr9sH6uho+ZxERkStB4ZWI2L3y8nKWLFnC+PHjSUhI4Mknn+TTTz+1dVnSjC5cuMCnn35KUlISZ8+etXU5IpctMzMTk8nEqlWrAHBzc7OuiPq5gIAAduzYQXx8PMnJybRv354ePXqwYsUKVq1axYgRIwCYM2cOJpOJPXv28P3332MymZg+fToAS5cuZdy4ccyfP5+OHTsSFBTE4sWLGTVqFAAxMTEEBQUxduxYvLy82Lt3L3FxcWRlZZGfn09UVBQVFRVs2bIFZ2dnnn322Sv0KTWP4OBgMjIyCA8PZ/jw4QQEBPDII48wYcIEQkNDKS8vx2QykZSUBPy0JXDnzp08+OCDTJw4EX9/f3r37s3Zs2fZsGEDY8aMadD8ycnJV8XnLCIiciWYjLoOQBC5CiQlJXH06FE++eQTW5civ+DLL78kPj6e77//HkdHRyorK2nTpg3nz58nMjKS5cuXExAQYOsy5VfU9+/bjh07ePfdd/nPf/5Dfn4+8NMh1G3btr0SZYq0anfffbc1MImNjSUxMZFBgwbh6up6yWvWrVvHwIEDKSws/MXD5MW2vL29mTt3rjWIExERaWXW6WmDImK3jh49yj333MPZs2epqqqiqqoKgPPnzwM/rWi499572bVr1y9upxH79u233/Luu++yePFijhw5grOzs/XPWESaTvXvK8+fP88HH3zAypUrcXNz44EHHuChhx6iX79+ODo62rhKERERkdq0bVBE7NaMGTMoLS3lwoULdb5fUVFBVlYWixcvvsKVSWMdP34cs9lM7969ufHGG5k9ezZHjhwBUHAlcgVUVlZiGAbnzp3j7bff5t5778Xf359x48axdevWOp9MKCIiImIrCq9ExG6tWLHiVw+zNQyD999//wpVJI1RUVHB4sWLiYqK4tprr+XJJ59k165dgAIrEVuqfophUVERb731FpGRkXTs2JFJkyZx8OBBG1dnf0wm06++ZsyYYesyRUREWhXtsxERu1RSUkJRUdGv9quqqtIPV3Zu9erVfPLJJxw7dozNmzdb2+v7lK127do1U2UiV5fqrde/pDpIzsvL45VXXrG2z58/nz/96U84Ozs3W30thValiYiIXHkKr0TELrm4uGAymer1Q4Kbm9sVqEguV0xMDN27d6ewsNC6DdRkMtXrB2mAqKgonWkm0gR27drF6dOn69XXwcEBwzBo164dp0+fJiEhQcGViIiI2Ix+GhARu9SmTRt69OjBt99++6v9fvvb316hquRyuLi40KVLF0wmE6tWrWL16tUsWrSI9evXYxgGhmH8YpC1fPlyPW1QpAncddddvxheVT8s4frrr+ehhx4iMTGRQ4cOMXDgQNq3b38FK20+S5Ys4cEHHwR++t5UVlZm44pERESkPnTmlYjYreTkZBwcfvnbVGVlpR4N3oJUP9nso48+4tSpU7z55ptERkZiMplo06YNJpPJ1iWKtBolJSXccMMNxMbGXrJP9WqqwMBAHn/8cXbv3s13333HjBkzuP76669UqXW64447frH2y5GQkIBhGERHRzfpuCIiItK8FF6JiN0aO3YsAwcOrPPR7dUhR1paGrfeeuuVLk2agK+vL6NHj2bz5s0cPnyY5557jhtvvBFA25NEmkD1qsaLVzZWb8P18/Pj8ccfJyMjgxMnTmA2m/X9VEREROySwisRsVtOTk6sWrWKtLQ0fHx8arwXFBTEe++9x9NPP22j6qQpVT99MCsri3379jF16lSuvfZaW5cl0qJ5eXlx6NAhPvroIwAcHR3x9PQkMTGR9evXc+rUKcxmM3fccYdWPYqIiIhdU3glInbNycmJ1NRUjh49islk4rnnnuPgwYMcOnSI4cOH27o8aQY9e/Zk5syZHDlyhB07duDq6mrrkkRahRdffJH8/HwWLVpE//7961zVKiIiImKPFF6JSItw5MgRDMPgvvvuIzg42NblyBUSHh6uLYQiFykvL+eZZ56hR48euLu74+fnx9ChQ/nggw+4cOECAOnp6ZhMJuurrKyM22+/nfnz51vbOnXqxM6dO4mOjsbLywt3d3fuuecetm3bZuM7bDr79+8nPj4eb29vPDw8iIyMZOvWrZfsf+bMGSZPnkxwcDDOzs74+voyaNAgNm3a1KB5CwsLa3z+JpOJZ599FvjprMaft+sXMSIiIr9O4ZWItAgWiwWArl272rYQEREbS05O5pVXXmH+/PmcOXOGb7/9lh49ehAXF8fnn38OQHx8PIZhEBcXV+PaKVOmYBgGYWFhFBYWMmnSJJ599lny8vLYsmULBQUF9OvXj88++8wWt9akDh48SEREBLt27WL58uWcPHmSBQsWkJaWxqFDh2r1z8vLIzw8nHfeeQez2Ux+fj7bt2/H3d2d6Oho3njjjXrP7ePjg2EYDBgwAAcHBw4ePMj06dOBn1YUG4ZBREQEb7/9NsuXL2+yexYREWmtFF6JSItgsVgIDAzE09PT1qWIiNjUxo0bCQkJISYmBjc3Nzp06MCLL75It27dGjTO2bNnWbBgAREREXh4eHD77bfzn//8h/PnzzNp0qRmqr5uTk5OtVYqbd++nTVr1tRqDwwMrNeY06ZNo7CwELPZTExMDJ6enoSGhrJo0SJyc3Nr9U9NTSUnJ4d58+YRGxtL27Zt6datG++88w7XXHMNEydO5OTJkw26r8mTJ1NVVcVLL71Uo33btm0cPXqUBx54oEHjiYiIXK0UXolIi5CTk8N1111n6zJERGxu4MCBfPHFF4wdO5bMzEzrVsEDBw4QFRVV73E8PDzo1atXjbbQ0FA6duzInj176gx4mktlZSWGYdR49enThyFDhtRqz8vLq9eYa9euBWDAgAE12jt27Fhn0Ldy5UoAhgwZUqPdxcWF6OhoSktLWbduXYPu69577yU0NJS33nqLM2fOWNtffPFFJkyYQJs2bRo0noiIyNVK4ZWItAgWi0XhlYgI8Pe//53FixdjsViIjo6mbdu2DBw40Bq+1NfFT3GtFhAQAMCpU6caXautlJeXU1xcjKura50rdqvv8ef9i4qKcHV1xcvLq1b/Dh06ANQ7OPu5lJQUzp07x4IFCwDIzs7m008/ZezYsQ0eS0RE5Gql8EpEWgSFVyIiPzGZTPz+979nw4YNFBYWkp6ejmEYDBs2rNb2tF9y5swZDMOo1V4dWl0c8LQkLi4ueHl5UVZWRklJSa33CwoKavX39vamrKyM4uLiWv2rtwvWd8vizz300EN06NCBV199lfLycubOncvDDz+Mr69vg8cSERG5Wim8EhG7ZxgGhw8fJigoyNaliIjYnI+PD/v37wegTZs2xMTEWJ8uuGbNmnqPU1ZWxs6dO2u0/fe//+XEiROEhYVxzTXXNGndV9qgQYOA/20frJafn8+BAwdq9b///vsBan2G5eXlbNy4ETc3t1pbEOvDxcWF8ePHc+rUKebOncvbb799xc8UExERaekUXomI3cvNzeXcuXNaeSUi8v89/vjj7N27l/Lyck6dOsXf/vY3DMOgX79+9R7D29ubadOmkZGRwdmzZ9m1axeJiYk4OztjNpubsfor4/nnn8fPz4+UlBTWr19PSUkJ+/btIzExsc6thLNmzSIoKIiUlBRWr15NcXEx2dnZjBo1itzcXMxms3X7YEONHz8eNzc3pk+fTv/+/bn++usbe3siIiJXFYVXImL3LBYLgMIrERHgs88+o0ePHiQkJODn50fPnj1Zu3Yt//znP5k2bRqAdSXWqlWrAHBzcyMxMbHGOJ6ensyfP5+//vWvXHPNNdx11134+vry6aefcvfdd1/x+2pqwcHBZGRkEB4ezvDhwwkICOCRRx5hwoQJhIaGUl5ejslkIikpCfhpS+DOnTt58MEHmThxIv7+/vTu3ZuzZ8+yYcMGxowZc9m1tGvXjsTERAzDYPLkyU11iyIiIlcNJ1sXICLyaywWCy4uLnTs2NHWpYiI2FxYWBivvfbaL/aJj4+v8zyri1UHX/YoMzOz0WN069atzoPsL36iYDV/f39efvllXn755UbPfbGIiAi+/PJL7rrrriYfW0REpLXTyisRsXsWi4WgoCAcHPQtS0REWqbXXntNq65EREQuk34SFBG7l5OToy2DIiLSorzxxhvcf//9lJSU8Nprr/HDDz8wYsQIW5clIiLSIim8EhG7Z7FYFF6JiDSBOXPmYDKZ2LNnD99//z0mk4np06fbuqwWxWQy/eprxowZwE9nj/n6+vKPf/yDJUuW4OSkEztEREQuh/4FFRG7Z7FYrI8wFxGRyzdlyhSmTJli6zJatPqcJVat+jB4ERERaRytvBIRu1ZWVkZubq5WXomIiIiIiFylFF6JiF2zWCwYhqHwSkRERERE5Cql8EpE7JrFYgEgKCjIxpWIiEhLUlJSwg033EBsbKytSxEREZFGUnglInbNYrEQEBCAl5eXrUsREZEWxDAMqqqqqKqqqvWep6cnffv2tUFVTe/f//4358+fJyMjgw0bNvDNN99w5swZW5clIiLSpHRgu4jYtZycHG0ZFBGRBvPy8uLQoUO2LqPZDR06lIqKCt58803efPNNa3ubNm3w9/fnN7/5Db/5zW/o3LkzHTp0oGPHjgQGBlr/GxAQgKOjow3vQERE5NcpvBIRu2axWBReiYiIXIKPjw/u7u4EBASQk5NjXWlWUVFBXl4eeXl57N69mzZt2uDg4EBlZSUXLlywXn/fffexatUqW5UvIiJSL9o2KCJ2TeGViEjrd/r0aSZOnEjXrl1xdnamffv2DBs2jK+//trap2/fvphMJusrMTERgP79+9doLywsJD09vUZbWVkZAHPmzMFkMnH27Fm2bdtmfd/JqWX/PtdkMvHHP/6RyMhI2rRpU2efiooKysvLawRXAE8++eSVKFFERKRRFF6JiF07fPiwDmsXEWnFcnNzCQ8PZ9myZSxYsICCggI2b95MQUEBERERZGRkALB161a+/vprPDw8CAsLY+HChQCsWbOGPn368O6772IYBj4+PsTHx2MYBnFxcTXmmjJlCoZh4OHhwZ133olhGBiGQWVlZY1+/fr1w9/fn8zMzCvzITQBFxcX1q1bx7333luvMM7R0ZHbbrut1Zz9JSIirZvCKxGxWydPnqSkpEQrr0REWrHU1FSOHDnCSy+9xODBg/H09CQkJIQlS5ZgGAYTJkyw9g0LC2PRokXs2bOH0aNHYxgG48aNIzo6moSEhCarqaqqyhpstSQuLi6sWLGCwYMH/+o5VlVVVTzzzDNXqDIREZHGUXglInbLYrEAKLwSEWkhsrKyamzXM5lMJCcn/+I16enpODg4EBsbW6M9MDCQkJAQdu/ezfHjx63tDzzwAE8//TQrVqygb9++nDlzhrS0tCa9j5+v/GppnJ2def/99xkxYsQlAyyTyUSHDh3o2rXrlS1ORETkMim8EhG7ZbFYcHZ25je/+Y2tSxERkXq46aabrCuWql+vvvrqJfuXl5dTVFREVVUV3t7etYKvL7/8EoDvvvuuxnVpaWn06dOHL774ggceeAAHB/0v7c85OTnx73//m1GjRtX52ZhMJtq2bUuvXr2IjY1ly5YtNqhSRESk/vQvvYjYLYvFQpcuXfQIbxGRVsrFxQUfHx+cnJyoqKioFXxVv+65554a123evJmioiJCQ0MZP348e/bsadC8JpOpKW/DLjk6OvLWW2/x8MMP1wqw2rVrx969e/nkk08wmUzcfffd3HbbbSxevLjWge4iIiL2QOGViNitnJwcbRkUEWnlhg0bRmVlJdu2bav13uzZs7n22mtrHKiek5PDY489xvvvv88HH3yAm5sbcXFxnD59ut5zuru7c/78eevX3bt35/XXX2/cjdghBwcH3njjDcaMGWMNsJycnHjyySdxcXGhf//+fPjhh+zatYuQkBAeffRRunfvjtlsprS01MbVi4iI/I/CKxGxWxaLReGViIiNHDx4kPnz5zf7PLNmzSI4OJhHH32Ujz/+mKKiIgoKCli4cCEzZ85kzpw51qfnlZSUEB8fz7x587jxxhvp2rUry5cv58SJEwwfPpyKiop6zXnrrbeSnZ3NsWPHyMjIwGKxEBkZaX2/JT5t8FIcHBz4xz/+YT343tXVlbFjx9boU73q6sCBAwwZMoSnnnqKrl27MmPGDH744QdblC0iIlKDwisRsVsWi4WgoCBblyEiclWprKzkhRde4Oabb2bfvn3NPl9AQAA7duwgPj6e5ORk2rdvT48ePVixYgWrVq1ixIgRACQnJ+Pl5cXevXuJi4sjKyuL/Px8oqKiqKioYMuWLTg7O/Pss8+Snp6OyWRi1apVALi5uZGYmGidc968edx888307NmTkSNHYjab6dmzZ43PoCU+bfBSTCYT8+bN409/+hPJycm0bdu2zn7BwcGYzWYOHz7M//3f/2E2m+nSpQuTJk2qcWi+iIjIlWYyWsu/yiINlJSUxNGjR/nkk09sXYrUoby8HHd3d5YtW8bvfvc7W5cjjaS/byItw9dff82YMWPIyspi6tSphIeHExsbS2FhId7e3rYuTy7B29ubuXPnkpSU9Kt9S0tLcXNzq9e4xcXFvPnmm7z44oucPn2akSNH8tRTT3HjjTc2tmQREZGGWKeVVyJilw4fPkxVVZW2DYqIXAGlpaU89dRT3H777bi6uvLVV18xY8YM63Y9aT3qG1wBeHl5MWnSJCwWC//85z/ZtWsXN910E0OHDq3zjDIREZHmovBKROySxWIB0LZBEZFm9tlnn9GrVy9ee+015s6dy2effUaPHj1sXZbYEWdnZ0aPHk1WVharVq3izJkz9O3bl759+/Lee+9RVVVl6xJFRKSVU3glInbJYrHg7++Pj4+PrUsREWmVfvjhB8aNG8c999xDt27dyMrKYtKkSdan0olczMHBgaFDh/LFF1/w+eef4+vry8iRI61PKCwrK7N1iSIi0krp/05ExC7l5ORoy6CISDN577336NGjBx9++CHLli3jww8/pFOnTrYuS1qQvn378uGHH7Jnzx4iIiJ48sknCQoKYsaMGRQWFtq6PBERaWUUXomIXbJYLAqvRESa2IkTJ7j//vsZOXIkAwYMICsri+HDh9u6LGnBQkNDWbx4MUePHmXcuHHMmzfP+oTCEydO2Lo8ERFpJRReiYhdUnglItJ0qqqqeP311+nRowdZWVls2LCBxYsX4+fnZ+vSbGbJkiWYTCZMJhOurq62LqfFCwwMZMaMGRw9epSZM2eyfPlygoKCGD16NPv377d1eSIi0sIpvBIRu5STk6PD2kVEmkBWVhZ33nknycnJjB8/nqysLPr162frshrkjjvuIDY2tknHTEhIwDAMoqOjm3Tcq13btm1rPKFwx44dhISEMHToUDIzM21dnoiItFAKr0TE7pw+fZoff/xRK69ERBqhoqKC2bNnc9ttt3H+/HkyMzN54YUXcHFxsXVpchVwcXFh9OjR7Nu3j/T0dE6fPk1ERIT1rCzDMGxdooiItCAKr0TE7lgsFgCFVyIil2nr1q2EhYUxc+ZMZs6cyY4dO7j11lttXZZchaqfUJiZmWl9QmFcXBy9evVi8eLFVFZW2rpEERFpARReiYjdsVgsODk50blzZ1uXIiLSohQVFTFp0iTuvvtugoKC2LdvH1OnTsXR0dHWpYlYV1199dVXhIWF8dhjj3H99ddjNps5e/asrcsTERE7pvBKROyOxWKhS5cuODk52boUEZEW48MPP+Smm25iyZIlLFq0iDVr1tClSxdbl2U39u/fT3x8PN7e3nh4eBAZGcnWrVsv2f/MmTNMnjyZ4OBgnJ2d8fX1ZdCgQWzatOmy5vfx8bEeEH/xy8HBgePHj1/urbU4YWFhLF68mO+++464uDimTZtG165deeqpp8jNzbV1eSIiYocUXomI3cnJydGWQRGResrLy2PEiBHcd999RERE8M033zB69Ghbl2VXDh48SEREBLt27WL58uWcPHmSBQsWkJaWxqFDh2r1z8vLIzw8nHfeeQez2Ux+fj7bt2/H3d2d6Oho3njjjcuqo7i4GMMwrK+ZM2cC8Nxzz9GpU6dG3WNL1LVrV8xmM0eOHOGJJ57gjTfesD6hMDs729bliYiIHVF4JSJ2x2KxKLwSEfkVhmGwePFiQkJC2LVrF+vWrWPZsmW0a9fO1qU1ipOTU62VSdu3b2fNmjW12gMDA+s15rRp0ygsLMRsNhMTE4OnpyehoaEsWrSozpU+qamp5OTkMG/ePGJjY2nbti3dunXjnXfe4ZprrmHixImcPHmyUfe5bNky/vKXv/DII4+QmpraqLFaunbt2jFjxgyOHDnCK6+8QmZmJj179mTo0KHs3LnT1uWJiIgdUHglInbHYrEQFBRk6zJEROzWoUOH6N+/P4899hiJiYns3buXe++9t8nncXZ2Bn56cuGVUllZWWN1kmEY9OnThyFDhtRqz8vLq9eYa9euBWDAgAE12jt27Ei3bt1q9V+5ciUAQ4YMqdHu4uJCdHQ0paWlrFu3rkH3VVhYiKenJwDbt2/n4Ycf5q677mLhwoUNGqcu58+fbxVPkfTw8GDs2LHs37+f9PR0Tp48Se/eva1nZYmIyNVL4ZWI2JWKigqOHz+ulVciInWorKxk9uzZ3HTTTeTn5/PFF19gNputoUhT8/X1BaCgoKBZxr8SysvLKS4uxtXVtc7PKSAgoFb/oqIiXF1d8fLyqtW/Q4cOAPUOzi529OhR4uLi6Ny5MytWrLAGhJfr3LlzlJWVWf+sWoPqJxTu2LHD+oTC++67j1tuuUVPKBQRuUopvBIRu3L48GEuXLig8EpE5CJfffUVffr04a9//StTp05l586dhIeHN+uc119/PQ4ODuzbt69Z52lOLi4ueHl5UVZWRklJSa33Lw7mXFxc8Pb2pqysjOLi4lr9q7cL1nfL4s8VFxcTGxtLRUUFq1evxs/Pr8FjXKz6z6auFWStQfWqqy+//JLQ0FAeffRRunXrhtls5ty5c7YuT0RErhCFVyJiVywWC4DCKxGR/+/cuXM89dRThIeH4+npyVdffcWMGTMavWKnPjw9PbnxxhvZsmVLs8/VnAYNGgT8b/tgtfz8fA4cOFCr//333w/AmjVrarSXl5ezceNG3Nzcam1B/DUXLlwgISGB/fv38/7779cIm4YPH056enqDxqu2ZcsW/Pz8CA4OvqzrW4rqVVfZ2dkMHTqU1NRUunbtyowZM1r0ykAREakfhVciYlcsFgs+Pj6tavuDiMjl+vjjj7nxxhtZuHAhCxYsYPPmzXTv3v2K1jB48GDS09Opqqq6ovM2peeffx4/Pz9SUlJYv349JSUl7Nu3j8TExDq3Es6aNYugoCBSUlJYvXo1xcXFZGdnM2rUKHJzczGbzdbtg/X1xz/+kY8++ojXX3+dqKioJrqzn87nGjhwII6Ojk02pj277rrrMJvNHD58mPHjxzN//ny6dOnCpEmTOHr0qK3LExGRZqLwSkTsSk5OTqv/7bGIyK8pKChg3LhxDB48mNDQULL+H3t3Hldj3v8P/HXaVy2krJWkpAWJkLGGGW3C1GDOWFIG9xzjNncZM0TGZDQ3x2BUfjdiboOxJGPf0+IuSxQVrpOtopSmtEzL5/fH/e3ccxTOSXW1vJ+PRw+Prq7l9bmu6+icd5/r80lNhb+/PwQCQbNn+eyzzyCRSHD69OlmP3ZjsbCwQEJCApycnDB16lR07twZs2bNwt/+9jfY2dmhoqICAoEAfn5+AP77SGBSUhI++eQTfPHFF+jYsSMGDx6MV69e4ezZs5g3b55Cx7927Rp++uknAMDs2bPrzJp48ODBBrUrNTUVV65cwWeffdag7Vuzzp07S2coXLNmDQ4fPozevXtDKBQiNTWV73iEEEIamYAxxvgOQQgf/Pz88OjRo1b9Zrwtmjp1KpSUlLB//36+o5BGRK83QuR34MABLFy4EKqqqvjpp5/g7e3NdyRMmjQJ2dnZSE5Objc9fFqDSZMm4enTp7h+/TqUlNr336QrKyuxd+9e/PDDD0hLTnpFogAAIABJREFUS8Pw4cMRGBgId3d3vqMRQgh5f6fa9285QkiLw3EcjXdFCGmXJBIJJk6cCB8fH0yePBl3795tEYUrABCLxbh79y4iIyP5jkL+z7Fjx3D8+HFs3Lix3ReuAEBVVRVCoRC3b9/G0aNHoampCQ8PDzg6OiIqKgrV1dV8RySEEPIe6DcdIaRFkUgkMDc35zsGIYQ0m5qaGkRERMDe3h4cx+H8+fMIDw9Hhw4d+I4m1bt3byxatAjffPMNsrKy+I7T7hUUFEAkEuHjjz9u1PGz2gKBQAB3d3ecOXMGycnJ6NevH+bMmQMrKyuIxWKUlZXxHZEQQkgDUPGKENJiFBQU4OXLl9TzihDSbty6dQtDhw7FokWLsHDhQty+fbvFFiOCg4PRo0cPuLu7448//uA7Tovw+thV9X0FBwc36jErKysxdepUVFVVYdOmTY2677amttdVeno6Jk2ahKCgIJibmyM4OBiFhYV8xyOEEKIAKl4RQloMjuMAgIpXhJA2r6ysDMHBwXBycoKKigpu3ryJ0NBQqKur8x3tjXR0dHD06FG8ePECPj4+KC8v5zsS7xhj7/xqzOJVdXU1/P39kZycjJiYGIVnPGyvevfuLZ2hcP78+RCLxdIZCp88ecJ3PEIIIXKg4hUhpMXgOA7Kysro2bMn31EIIaTJxMbGYuDAgdiwYQN++OEHxMbGwsbGhu9YcunRoweio6ORmJiIsWPHIi8vj+9I7UZJSQm8vb3x66+/4tdff4W9vT3fkVodY2NjBAcH49GjRwgJCcHBgwdhYWEBoVCIO3fu8B2PEELIW1DxihDSYnAch549e0JVVZXvKIQQ0uhevnyJgIAAjBw5EhYWFkhNTYVIJGp1g207OTkhPj4ez549w5AhQ5CcnMx3pDbv3r17GDFiBBITE3H+/Hl89NFHfEdq1XR1dSESicBxHCIjI5GcnAw7Ozu4u7sjPj6e73iEEELq0breLRFC2jSJREKPDBJC2qSYmBjY2toiOjoaO3fuxLFjx9CjRw++YzVY3759kZiYCHNzcwwZMgT+/v7UC6sJFBcXIzAwELa2thAIBLh69SqGDh3Kd6w2Q01NDUKhEKmpqThy5AhevHiB4cOHw8XFBTExMWCM8R2REELI/6HiFSGkxeA4jmYaJIS0KTk5OZg6dSo8PT0xZswYpKWlQSgU8h2rUXTq1Alnz57Fnj17cOLECVhaWuLLL7/EjRs3+I7W6qWnp+Pbb7+FpaUltm/fjg0bNiApKQlmZmZ8R2uTlJSUpL2uYmNjYWBgAE9PT+kMhTS+GyGE8E+F7wCEEFKL4ziMHj2a7xiEEPLeGGOIjIzEV199hU6dOuH06dMYN24c37EanUAgwCeffAIPDw9s3rwZ4eHh2LhxI7p06YKBAweiR48e0NPT4ztmq1BcXIzs7GzcuHEDDx8+RJcuXeDn54cvv/wSHTt25Dteu+Hi4gIXFxfcvn0b69evx1dffYXQ0FAEBARg8eLF0NfX5zsiIYS0SwJG/WFJO+Xn54dHjx7h9OnTfEchAKqqqqClpYWoqCj4+vryHYc0Mnq9kfbk3r17CAgIQGxsLBYsWIC1a9dCW1ub71jNgjGG69ev49y5c0hJSUFubi6Kior4jtVkXr16hefPnzdKr2EdHR107twZ9vb2GD16NJydnaGsrNwIKcn7ePjwIX7++Wds27YNjDHMmjULgYGB6Nq1K9/RCCGkPTlFPa8IIS3Co0ePUFlZSWNeEUJarcrKSvzzn//EypUr0bdvXyQkJGDQoEF8x2pWAoEAjo6OcHR05DtKs7h79y5sbW0RGBiIadOm8R2HNAFTU1OEhobi66+/xo4dO7Bu3TqEh4fj448/xvLly2FlZcV3REIIaRdozCtCSIvAcRwAUPGKENIqxcfHY8CAAVi1ahVWrVqF5OTkdle4ao/69u2LqVOnYtWqVaipqeE7DmlCHTp0gEgkgkQiQUREBP7zn//AxsYG7u7uSExM5DseIYS0eVS8IoS0CBzHQVdXF506deI7CiGEyK20tBRBQUH44IMP0KlTJ6SkpCAwMJAe92pHVqxYgbt37yI6OprvKKQZqKurQygU4s6dOzhy5Ajy8vIwdOhQmqGQEEKaGBWvCCEtgkQigYWFBd8xCCFEbr///jv69u2LiIgIbN26FRcuXIClpSXfsUgz69evH7y8vLB69WoqXLQjtTMUJiYmysxQ2L9/f0RFRaGqqorviIQQ0qZQ8YoQ0iJwHEePDBJCWoVnz55BKBTCzc0NQ4YMQUZGBvz9/SEQCPiORniyYsUKpKSk4NixY3xHITyo7XV148YNODg4YO7cubC0tIRYLMarV6/4jkcIIW0CFa8IIS0CFa8IIa3BgQMHYGtri/Pnz+Pw4cPYv38/jIyM+I5FeObg4AAPDw8EBwdT76t2zMHBAVFRUcjMzISHhwe+/vprmJmZITg4GPn5+XzHI4SQVo2KV4SQFoHjuEaZapwQQpoCx3FwdXWFr68vvL29cffuXXh5efEdi7Qg33//PW7duoW9e/fyHYXwzNzcHGKxGFlZWVi4cCE2b96M7t27QygU4t69e3zHI4SQVomKV4QQ3hUVFaGgoIB6XhFCWpyqqiqIxWLY29vj2bNniI+PR3h4OHR1dfmORlqYvn37QigUYvny5aioqOA7DmkBjIyMEBwcjIcPH2LdunW4dOkSrK2t4e7ujqSkJL7jEUJIq0LFK0II7x48eAAAVLwihLQoKSkpGDp0KIKCgrB06VIkJydjyJAhfMciLVhISAieP3+OzZs38x2FtCDa2toQiUSQSCQ4cuQIcnNzMXjwYOlYWYQQQt6NileEEN5xHAclJSWYmpryHYUQQlBWVoagoCA4OjpCQ0MD169fR3BwMNTU1PiORlq4rl27YvHixfjuu+9QUFDAdxzSwtTOUJiUlCSdodDDwwMDBgygGQoJIeQdqHhFCOEdx3Ho3r071NXV+Y5CCGnnLl26hP79+2Pbtm348ccfcenSJfTt25fvWKQVCQoKgpqaGkJDQ/mOQlqw2l5X169fh52dHebMmQMrKyuIxWKUlZXxHY8QQlocKl4RQngnkUjokUFCCK8KCwsREBCA0aNHo0+fPkhNTYVIJIKSEr1VIorR1dXF8uXL8dNPP0kfiyfkTWp7XWVmZsLNzQ3Lli2DqakpgoODqfceIYT8Bb0jI4TwjuM4Kl4RQnhz4MABWFtb4+jRo9i/fz9iYmLQvXt3vmORVuzzzz+HlZUVFi5cyHcU0kr06tVLOkPhggULsGnTJpiamkIkEuHx48d8xyOEEN5R8YoQwjuO42Bubs53DEJIO5OdnQ1vb2/4+PhgwoQJSEtLw9SpU/mORdoAFRUVbN68GadPn8ahQ4f4jkNakc6dOyM4OBiPHj3CmjVrcPjwYVhYWEAoFCItLY3veIQQwhsqXhFCeFVdXY1Hjx5RzytCSLOpqalBREQErK2tcfv2bZw9exZRUVEwNDTkOxppQ1xcXCAUCiESiVBSUsJ3HNLK6OjoQCQS4f79+9i+fTuuXbsGOzs7uLq60gyFhJB2iYpXhBBePX78GH/++ScVrwghzSI1NRXDhw/HokWLsGDBAty+fRtjxozhOxZpo3788UeUl5dj9erVfEchrZSamhqEQiFSU1MRHR2NsrIyeHh4wNHREVFRUaiuruY7IiGENAsqXhFCeMVxHABQ8YoQ0qQqKyuxbt06DBo0CBUVFUhMTERoaCg0NDT4jkbasI4dOyIkJAQbNmxASkoK33FIKyYQCODu7o4rV64gOTkZ/fr1k5mhsLy8nO+IhBDSpKh4RQjhFcdx0NHRQefOnfmOQghpo+Li4uDg4IDVq1dj1apVSEpKwsCBA/mORdoJf39/ODo64vPPP6deMqRR1Pa6Sk9Px6RJkxAUFAQzMzMEBwejsLCQ73iEENIkqHhFCOGVRCKhXleEkCZRVFQEkUiEDz74AGZmZrhz5w4CAwOhrKzMdzTSjigpKWHHjh24efMm1q1bx3cc0ob07t1bOkPh/PnzIRaLpTMUPnnyhO94hBDSqKh4RQjhFcdxVLwihDS6mJgY2NnZYc+ePfj5559x/PhxmJqa8h2LtFN9+/bF6tWrERwcjOTkZL7jkDbG2NhYOkNhSEgIDh48KJ2h8O7du3zHI4SQRkHFK0IIr6h4RQhpTLm5uRAKhfDw8ICzszMyMjLg7+/PdyxCsGTJEgwbNgyfffYZjU9EmoSuri5EIhE4jkNkZCSSkpJga2sLd3d3xMfH8x2PEELeCxWvCCG84jgO5ubmfMcghLRyjDFERUXB1tYWV65cwalTp7B//3506tSJ72iEAPjf44OPHz/GypUr+Y5D2rDaGQrT0tJw5MgR5OfnY/jw4XBxcUFMTAwYY3xHJIQQhVHxihDCm+LiYuTn51PPK0LIe3nw4AFcXV0xd+5czJgxA7du3cL48eP5jkVIHebm5vjnP/+JsLAwXLlyhe84pI1TUlKCu7s7EhISEBsbCwMDA3h6esLe3h4RERGoqKjgOyIhhMiNileEEN5wHAcAVLwihDRIVVUV1q1bB1tbW+Tl5SE+Ph5isRg6Ojp8RyPkjfz8/PDRRx9h+vTpyM/P5ztOi7V06VJ6LTei2l5XKSkpGDBgABYtWiSdobCoqIjveIQQ8k5UvCKE8IbjOAgEApiZmfEdhRDSyty4cQPOzs5YtWoVAgMDkZSUBCcnJ75jESKXqKgoqKqqwsfHB9XV1XzHUUhYWBgEAgEEAgG6d+/+zuWkZbGzs0NUVBTu3buHjz/+GGFhYejZsydEIhGys7P5jkcIIW9ExStCCG84jkO3bt2goaHBdxRCSCtRWlqKoKAgODk5QVtbGzdu3EBwcDDU1NT4jkaI3AwMDHDo0CEkJCS0uvGvli5dCsYYHBwc5FpOWiZTU1OIxWI8ffoUq1evxoEDB9CrVy8IhUJkZGTwHY8QQuqg4hUhhDcSiYQeGSSEyO3EiROwsbFBeHg4tm7diosXL8LKyorvWIQ0iIODAzZt2oS1a9fi8OHDfMch7ZSenh5EIhEkEgkiIiJw9epV2NjYwN3dHVevXuU73jvp6OjAxcWF7xiEkGZAxStCCG84jqPiFSHknQoLCxEQEICPPvoIdnZ2SE1Nhb+/PwQCAd/RCHkvfn5+mDNnDubMmYMHDx7wHYe0Y+rq6hAKhbh79y6OHDmC58+fw9nZmWYoJIS0GFS8IoTwhuM4mJub8x2DENKCHThwAFZWVoiJicHBgwcRExODbt268R2LkEazefNm9OrVC1OmTEFxcTHfcUg7VztD4dWrV2VmKBwwYACioqJQVVXFd0RCSDtFxStCCC9qamqQlZVFPa8IIfWSSCSYOHEifHx8MHnyZKSnp8Pb25vvWIQ0Og0NDRw8eBDPnz/HlClTUFlZqfA+vLy8pIOlCwQCmceozp07B4FAgJiYGOmyxYsXy6xfVVWFqqoq7Nu3D66urjAxMYGmpibs7OwgFotRU1PT4Pbt2bNH5lgCgQC5ubkN3t+bpKenw8vLC3p6etDS0sLgwYNx7NgxjBs3TnpcPz8/6fovXrzAkiVLYGFhATU1NRgYGODDDz/EhQsXGj1ba1Xb6+rGjRuwt7fH3LlzYWlpCbFYjNLS0iY7bkVFBVasWAFra2toaWnB0NAQ7u7uOHr0qHSCg9oJAl69eoW4uDjpNVZRUZHZlzzX+fXJBpKSkjB27Fjo6upCS0sLo0ePRlxcXJO1lxAiJ0ZIOzV37lzm6urKd4x269GjRwwAu3LlCt9RSDOg1xuRV3V1NQsPD2c6OjrM0tKSXbhwge9IhDSLW7duMX19ffbJJ5+wmpoahbffsmULA8B++eUXmeWzZs1iAJiPj4/M8sOHD7OxY8dKv4+JiWEA2Nq1a1lBQQHLy8tjmzZtYkpKSmzp0qV1jufg4MC6dev2zuVVVVVsyZIlzNXVlRUUFMjdnr///e9MW1tbrnXv3bvH9PX1Wbdu3djp06dZcXExS01NZePGjWNGRkZMXV1dZv2cnBxmbm7OjI2NWUxMDCsqKmIZGRnM29ubCQQCFhkZKXfO9oTjOPbFF18wLS0t1qlTJ7Zy5UqWn5/f6Mfx8/Njenp67PTp06y0tJTl5uaypUuXMgB1fidoa2uz4cOH17sfRa+zg4MD09bWZkOHDmXx8fGspKSEJSUlMXt7e6ampsYuXrzY6G0lhMjtJBWvSLtFH6b5dfHiRQaAZWdn8x2FNAN6vRF5pKSksMGDBzNVVVUWGBjIysvL+Y5ESLM6f/48U1dXZ8uWLVN42xcvXjA1NTU2ceJE6bLS0lJmYGDAevfuzTQ1Ndkff/wh/dnkyZPZrl27pN/HxMSwUaNG1dnvzJkzmaqqKisqKpJZLk/xqrCwkE2YMIGJRCJWVVWlUHsUKV5NmzaNAWC//fabzPLnz58zLS2tOsWr2oLe3r17ZZaXl5ezrl27Mk1NTZabm6tQ3vbk+fPnbOXKlaxjx45MW1ub+fv7s8zMzEbbv7m5ORs2bFid5X369FGoeKXodXZwcGAA2I0bN2TWv3XrFgPAHBwcGtgiQkgjOEmPDRJCeMFxHDQ1NWFiYsJ3FEIIz8rLyxEcHAwnJyeoqKjg5s2bCA0Nhbq6Ot/RCGlWo0ePxo4dOxAaGopNmzYptK2hoSE++ugjnDlzRvpYXnR0NIYMGYKFCxeirKwMhw4dAgAUFBTg4sWLMo/iurm51fvInIODAyorK5GWlqZQnoyMDAwZMgRKSkrYuHEjlJWVFdpeESdPngQATJgwQWa5kZERrK2t66xfO7vjpEmTZJarq6tj7NixKCsrw6lTp5oobetnZGSE4OBgZGVl4bvvvsPJkydhbW0Nd3d3JCUlvff+J06ciPj4ePj7+yMxMVH6qGBGRgZGjRol934acp21tbXRv39/mWV2dnbo2rUrUlJSkJOT04AWEUIaAxWvCCG8kEgk6NWrF80WRkg7FxsbiwEDBiAsLAyrV6/G5cuXYWNjw3csQnjzySef4LvvvsOSJUtw4MABhbYVCoWorq7Gv//9bwDA7t27IRQK8cknn0BZWRm//PILAGDv3r1wc3ODjo6OdNuioiKsWLECdnZ2MDAwkI4B9NVXXwGAQmMcFRYWwsvLC927d8eJEyewZ88ehdqhiIqKChQXF0NDQ0OmPbUMDAzqrF9UVAQNDQ3o6urWWd/Y2BgAmmRcrrZGR0cHIpEI9+/fx6+//orc3FwMHjxYOlZWQ23ZsgVRUVHgOA5jx45Fhw4dMHHiRGkxSh4Nvc76+vr17q9z584AgOfPn8udgRDSuKh4RQjhBcdxNFg7Ie3Yy5cvIRKJMGrUKFhYWODOnTsIDAxs0t4ZhLQWy5Ytw6JFizB9+nTs3btX7u0mTZoEQ0ND7N69G3l5eUhMTISXlxeMjY0xfvx4nD9/Hjk5Odi1axeEQqHMtu7u7ggJCcG8efOQmZmJmpoaMMawYcMGAABjTO4cKioqOHv2LKKjo2FnZ4d58+Y1So+c+qirq0NXVxfl5eUoKSmp8/PXiw3q6urQ09NDeXl5vbM7Pnv2DACoZ7gCVFVVMW3aNCQlJUlnKPTw8MDAgQMRFRUl7TklL4FAgE8//RRnz57Fy5cvceTIETDG4O3tjX/+85911q1PQ6/zixcv6r3Xa++j2iIWIaT5UfGKEMILKl4R0n7FxMTA1tYW+/btw44dO3Ds2DH07NmT71iEtCgbN25EUFAQPv30U+zYsUOubdTU1ODj44ObN29i+fLl8PT0hKamJgDg008/RXV1NVauXImcnByMGTNGul11dTXi4uJgYmKCL774AkZGRtKiQFlZmcLZdXV10a1bN+jo6ODo0aPQ0dGBl5dXkz1y9eGHHwL43+ODtXJzc5GZmVln/cmTJwMAfv/9d5nlFRUVOHfuHDQ1Nes8gkjkU9vr6tq1a7C1tcWcOXPQp08fiMViue8lfX19pKenA/hvYczV1RVHjhyBQCCoc820tLTw559/Sr+3srJCREQEgIZd5/Ly8jqF1tu3byM7OxsODg7o0qWLXG0ghDQ+Kl4RQnjBcRzMzc35jkEIaUY5OTmYOnUqPD09MWbMGKSlpdXp/UEI+Z+QkBB88803mDt3LjZv3izXNp9++ikAIDIyUub15eXlBV1dXURGRmLGjBlQUvrfxwBlZWWMGjUKubm5WL9+PfLz81FWVoYLFy5g27Zt79UGMzMz/Pbbb8jLy4O3tzcqKirea3/1Wbt2LQwNDbF48WKcOXMGJSUlSE1NxezZs+vtQfX999/D3NwcixcvxrFjx1BcXIzMzExMnz4dOTk5EIvF0sfKSMPU9rrKyMiAm5sbli1bBjMzMwQHB6OgoOCd28+fPx+3bt1CRUUFnj9/jh9++AGMMZmia+1xMjMz8fjxYyQkJIDjOIwYMQJAw66znp4evv76ayQkJODVq1dITk7GzJkzoaamBrFY3HgniBCiOF7HiyeERzT7GX9KSkqYQCBgR48e5TsKaSb0emvfampqWHh4OOvQoQPr1asXO3PmDN+RCGlVQkNDmUAgYBs2bJBrfUtLS9azZ09WU1Mjs7x29rW0tLQ62+Tl5bGAgADWo0cPpqqqyoyNjdmsWbNYUFAQA8AAMEdHR7Z+/Xrp97Vfy5cvZ3v37q2zfMOGDSwhIaHO8hkzZryzDYrMNsgYYxkZGczLy4t16NCBaWlpsWHDhrFLly6xUaNGMS0trTrr5+fns8WLFzNzc3OmqqrK9PT02IQJE9i5c+fkPiaR37Nnz9jKlSuZgYEB09HRYV988QV79OhRvevevHmTBQQEsL59+zItLS1maGjInJ2dWWRkZJ17Oj09nY0YMYJpa2uzHj16sC1btsj8XJHrXDtT5p07d9iECROYrq4u09TUZCNHjmRXrlxpvJNBCGmIkwLGFHiAnZA2xM/PD48ePcLp06f5jtLu3L59G/b29khNTUW/fv34jkOaAb3e2q/79+/D398fsbGxWLBgAdauXQttbW2+YxHS6vzwww8ICgrCypUrsWLFijY/4cnSpUuxbdu2esexUoS1tTXKysrw8OHDRkpG3kdxcTH+9a9/ISwsDM+ePYOvry8CAwNbxPvB/v37Iz8/H0+ePOE7CiGkrlP02CAhpNlxHAeBQECPDRLShlVWVmLdunWwtbVFYWEhEhISIBaLqXBFSAP94x//wLZt2/Ddd9/Bx8dHodn/2rrc3FwYGhqisrJSZnlWVhYePHhQ51Ezwh9dXV2IRCI8ePAA27dvx7Vr12BnZwd3d3ecPXuW73iEkBaMileEkGbHcRxMTEygpaXFdxRCSBNISEjAgAEDsGrVKqxatQrJyckYNGgQ37EIafX8/f1x/vx5XLp0CcOGDaPeRH9RWFiIgIAAPH78GKWlpfjPf/4DHx8fdOjQAd9++y3f8chr1NTUIBQKkZqaiujoaBQWFsLV1RWDBg1q0AyFhJC2j4pXhJBmJ5FIaKZBQtqg0tJSBAUFYcSIEejUqRNu3ryJwMBAKCsr8x2NkDbDxcUFCQkJqK6uxqBBg3D58mW+I/HOxMQEZ8+excuXL/HBBx/AwMAAHh4esLS0xH/+8x96z9GCCQQCuLu748qVK4iNjUWvXr0we/ZsWFtbQywWo7y8vMkzhIWFQSAQICUlBU+fPoVAIMA333zT5MclhCiGxrwi7RaNwcMfNzc3GBoaIioqiu8opJnQ663tO378OD7//HMUFxcjNDQU8+bNa/Nj8hDCp+LiYkyfPh1nzpzBli1bMHfuXL4jEdIo7t+/j59++gkRERHQ09PD/PnzsXjxYujr6/MdjRDCHxrzihDS/DiOo7+CEtJGPHv2DEKhEJMmTcKQIUOQnp4Of39/KlwR0sR0dXURHR2NJUuWwN/fH56ennj27BnfsQh5b71794ZYLIZEIsH8+fMhFovRs2dPiEQiPH36lO94hBCeUPGKENKsGGPIysqiwdoJaQMOHDgAW1tbnDt3DocPH8b+/fvRuXNnvmMR0m4oKSlh7dq1iI2Nxd27d2FtbY3du3fzHYuQRmFiYoLg4GA8fPgQISEhOHjwIHr16gWhUIi7d+/yHY8Q0syoeEUIaVbZ2dkoKyujnleEtGIcx2H8+PHw9fWFt7c30tPT4eXlxXcsQtqtYcOG4fr16/Dx8cFnn30GX19fZGdn8x2LkEbRoUMHiEQicByHyMhIJCUlwdbWFu7u7khISOA7HiGkmVDxihDSrDiOAwAqXhHSClVVVUEsFsPe3h65ubmIi4tDeHg4dHV1+Y5GSLuno6ODbdu24cSJE0hMTISVlRVCQkJQWlrKdzRCGkXtDIVpaWk4cuQI8vPzMWzYMLi4uCAmJgY0lDMhbRsVrwghzYrjOGhoaKBLly58RyGEKCAlJQXDhg3DV199hUWLFiE5ORnOzs58xyKEvGbChAnIzMzEmjVrEBYWhj59+iAiIgI1NTV8RyOkUSgpKUl7XcXGxsLAwACenp5wcHBAVFQUKisr+Y5ICGkCVLwihDQriUQCc3NzKCnRfz+EtAZlZWUIDg6Gk5MT1NTUkJKSgtDQUKipqfEdjRDyBmpqahCJRMjMzMRHH32EBQsWYOjQoTh16hTf0QhpVLW9rm7evIn+/ftj7ty56NmzJ4KDg1FUVMR3PEJII6JPj4SQZkUzDRLSely+fBn9+/fHxo0bsX79ely+fBl9+/blOxYhRE7GxsaIiIjA9evX0bFjR0ycOBGDBg3C4cOHqScWaVPs7e0RFRWF+/fv4+OPP0ZYWJh0hkIa/42QtoGKV4SQZkXFK0JavpcvXyIgIACjRo1Cnz59kJqaCpFIRD0mCWml7O3tcfz4caSkpMDGxgbTpk2DlZUVIiIiUFVVxXc8QhqNqakpxGIxnj59itWrV+PAgQPSGQozMjL4jkcIeQ/0LpQQ0qw4joO5uTnfMQghb3DgwAHqnS4JAAAgAElEQVRYWVnh6NGj2LdvH2JiYtC9e3e+YxFCGkFt75Rbt27B2dkZCxcuhJWVFcLCwlBQUMB3PEIajZ6eHkQiESQSCSIiInD16lXY2NjA3d0dV69e5TseIaQBqHhFCGk2ZWVlyM3NpZ5XhLRA2dnZ8Pb2ho+PDyZMmIC0tDRMmzaN71iEkCZgY2OD3bt3IyMjA5MmTcKaNWvQvXt3zJkzB0lJSXzHI6TRqKurQygU4u7duzhy5AieP38OZ2dnmqGQkFaIileEkGbDcRwYY1S8IqQFYYwhIiIC1tbWuHXrFs6ePYuoqCgYGhryHY0Q0sR69eqFTZs24cmTJ9iwYQOuXbuGwYMHY/Dgwdi5cyfKysr4jkhIo6idofDq1asyMxQOGDAAUVFR9PgsIa0AFa8IIc2G4zgAoMcGCWkhUlNTMWzYMCxcuBALFixAamoqxowZw3csQkgz09HRQUBAAFJSUpCcnIwBAwZgwYIFMDExgVAoRExMDKqrq/mOSUijqO11df36ddjb22Pu3LmwtLSEWCxGaWkp3/EIIW9AxStCSLORSCQwNjaGjo4O31EIadcqKyuxbt06DBo0CBUVFbh69SpCQ0OhoaHBdzRCCM8cHR0RHh6OrKwsrF69GmlpafDw8ICFhQW++eYbGvSatBn9+/dHVFQUMjMz4eHhga+//hqmpqYIDg7Gixcv+I5HCHkNFa8IIc1GIpHQI4OE8CwuLg4ODg5YvXo1Vq1ahaSkJAwcOJDvWISQFqZz584QiUS4du0aUlNT4evri127dsHa2hrOzs7YsGEDHj16xHdMQt6bubk5xGIxsrKysHDhQvz0008wNTVFQEAA7t27x3c8Qsj/oeIVIaTZcBxHxStCeFJUVASRSIQPPvgAZmZmuHPnDgIDA6GsrMx3NEJIC9evXz+Ehobi4cOHOHPmDKytrbF69WqYmZlh8ODBWLduHe7fv893TELei5GREYKDg/Hw4UN89913OHnyJKytreHu7o7k5GS+4xHS7lHxihDSbKh4RQg/jh07Bjs7O+zZswc///wzjh8/DlNTU75jEUJaGSUlJYwbNw47d+7Es2fPcPz4cTg4OCAsLAyWlpbo378/QkJCkJaWxndUQhpMR0cHIpEI9+/fx44dO5CVlQUnJyfpWFmEEH5Q8YoQ0iwYY5BIJDRYOyHNKDc3F0KhEO7u7nB2dkZ6ejr8/f35jkUIaQPU1NQwceJEREZGIjc3F7GxsRg5ciS2bdsGW1tbmJubIyAgAAcOHEBJSQnfcQlRmKqqKoRCIW7fvi2dodDDwwMDBw5EVFQUTWJASDOj4hUhpFk8e/YMr169op5XhDQDxhiioqJga2uLK1eu4NSpU9i/fz+MjIz4jkYIaYOUlZXh4uICsViMx48fIyEhATNmzEBSUhJ8fHxgbGwMd3d3bNu2jcbJIq1Sba+ra9euwdbWFnPmzEGfPn0gFotRVlbGdzxC2gUqXhFCmgXHcQBAPa8IaWIPHjyAq6srZs+ejSlTpuDWrVsYP34837EIIe2EkpISnJ2dsWbNGly/fh1PnjyBWCyGqqoqvvrqK5iamsLOzg5ffvklfv/9d+qVRVqV2l5XGRkZcHNzw7Jly2BmZobg4GAUFBTwHY+QNo2KV4SQZsFxHNTU1NCtWze+oxDSJlVVVUEsFsPBwQF5eXlISEhAeHg4dHR0+I5GCGnHunbtCj8/Pxw6dAj5+fk4ffo0xo8fjwsXLsDd3R2GhoYYMWIEVq1ahStXrqCyspLvyIS8k4WFhXSGws8//xybNm2CqakpRCIRHj9+zHc8QtokKl4RQpoFx3EwMzOjmc0IaQI3btyAs7Mzli1bhqVLlyIpKQmDBw/mOxYhhMhQV1eHq6srfvzxR9y8eRO5ubmIioqClZUVduzYgREjRsDQ0BBubm4ICwvD1atXUVVVxXdsQt6oc+fO0hkK16xZg0OHDqF3794QCoU0cQEhjYyKV4SQZiGRSGi8K0IaWWlpKYKCguDk5AQtLS1cv34dwcHBUFNT4zsaIYS8U+fOneHr64vt27cjKysL9+7dw/r166GlpYWwsDA4OztDX18frq6uWL16NS5dukTjC5EWSVdXFyKRCA8ePEBkZCSuXbsGOzs7uLu7Iy4uju94hLQJVLwihDQLjuOoeEVIIzp58iT69euH8PBwbN26FZcuXYK1tTXfsQghpMF69+6N+fPnY//+/cjNzcXdu3exYcMGdOnSBf/6178watQo6Ovrw8XFBcuWLUNMTAzy8vL4jk2IlJqamnSGwujoaBQUFMDFxQWDBg2iGQoJeU8qfAcghLQPHMfB3d2d7xiEtHqFhYUICgpCREQE3NzcsG3bNhpLjhDSJllbW8Pa2hrz5s0DADx69AiXL19GbGwsjh49inXr1oExht69e8PZ2RnOzs4YOnQo7O3toaJCH3Oayh9//IGkpCSkpaWhoKAA5eXlfEdqsUaMGAFzc3MkJibis88+Q2hoKDw8PPiORUiTEggE0NfXh5mZGQYMGIA+ffo0yn7pf3VCSJOrqKhAdnY29bwi5D0dOHAACxcuhIqKCn777TdMmTKF70iEENJsevbsiZkzZ2LmzJkAgJcvXyIxMVH6tXz5chQVFUFLSwuDBg2Cs7MzBg0ahIEDB8LCwoLn9K1bZWUlDh06hO3bt+PSpUuorKxE586dYWRkBA0NDb7jtXj6+vqwsbFBTU0Nzp49y3ccQpoUYwwFBQV4+vQpKisrYW5uDl9fXwQEBMDU1LTB+6XiFSGkyUkkEtTU1FDxipAGysrKwvz583H69GnMmzcP69evR4cOHfiORQghvNLX18fEiRMxceJEAEBNTQ3S09ORmJiI+Ph4HD9+HD/++COqq6uhr6+PAQMGYODAgdKvPn36QEmJRlF5l1OnTmHx4sW4d+8e3NzcsHPnTowZMwYmJiZ8RyOEtGB//vknkpOTcezYMezatQs//vgjRCIRvv32W+jq6iq8PypeEUKaHMdxAEDFK0IUVFNTg+3bt+Pvf/87unTpgnPnzmH06NF8xyKEkBZJSUkJNjY2sLGxwZw5cwD8t8dQZmYmrl27hmvXriExMRFbtmxBeXk5dHR0YGVlBRsbGzg6OsLR0RFOTk5QV1fnuSUtQ15eHvz8/HD06FFMmTIFx48fh7m5Od+xCCGthJqaGoYNG4Zhw4Zh9erViIiIwIoVK7Bnzx5s3rwZ3t7eCu2PileEkCbHcRw6depEPUUIUcDt27fh5+eHGzduYMmSJVi1ahV9oCKEEAWpqqqiX79+6NevH4RCIQCgqqoKGRkZ0oLWtWvXcPDgQZSWlkJVVRWWlpbSYlbtl6amJs8taV5paWlwd3eHkpISzp07hzFjxvAdiRDSiqmoqGDBggXw9fVFUFAQpk6dilWrVuGbb76BQCCQbx9NnJEQQiCRSKjXFSFyKi8vR2hoKL7//nsMGjQIN27cQL9+/fiORQghbYaKikq9Ba07d+7g+vXr0q/Dhw+jpKQEqqqqsLW1hb29vXQ7GxsbmJmZ8duQJnLu3Dl4e3vDwcEBhw4dQqdOnfiORAhpIwwNDREREQFHR0csWrQImZmZ2LlzJ5SVld+5LRWvCCFNjuM4Kl4RIofY2Fj4+/vj8ePHWL16NZYuXSrXL3NCCCHvR0VFBfb29rC3t8esWbMA/PfR7czMTGkx6/bt2zh79iyePn0KANDV1UXfvn1ha2sLGxsb6b89evTgpQ1//PEHNDU1oaqq2uB93L59G5MnT8akSZOwc+dO6vFLCGkSAQEB6NWrFzw9PWFgYIBNmza9cxsaoZAQ0uSoeEXI2xUVFUEkEmHUqFGwsLDAnTt3EBgYSIUrQgjhkZKSEqytrTF9+nSEhYXh1KlTePLkCV6+fInk5GRs3rwZo0ePxvPnz7F161Z8+OGH6NmzJ/T09DBo0CAIhUKsW7cOMTEx4DgOjLEmzXv8+HH07t0b/+///T9UVlYqvH1+fj4mT56M/v37t4jCVVhYGAQCAQQCAbp37/7O5a3Jnj17pG0QCATQ0dHhO1Kb8euvv0rPa1ufCbMltjUoKEjm3nZ2dn7juq6urti9eze2bNmCLVu2vHPfVLwihDQ5iURCA3wS8gYxMTGwtbXFvn37sGPHDhw7dgw9e/bkOxYhhJA30NPTg6OjI4RCIUJDQxETE4MHDx4gPz8fly5dwrp16+Ds7IwnT57gxx9/hIeHBywsLNCxY0eMGDEC8+fPx08//YQzZ87g4cOHqKmpaZRcEokET548gb+/PywsLLBjxw5UVVXJvf3MmTOhpKSEw4cP8164AoClS5eCMQYHBwe5lr9NSUkJLC0t4ebm1tgx38vPP/8MxhhKSkr4jtJm+Pr6gjGGsWPH8h2lyb2trXzd86GhoWCMgTEm1x9hp0yZgpCQECxevBg3b95867r02CAhpEk9f/4cxcXF1POKkNfk5OTgb3/7Gw4ePIhp06Zh69atNK4IIYS0YoaGhvjggw/wwQcfyCwvLCxEWloa7ty5I/03Ojoaubm5AP47I1f37t3Rq1cv2NjYoF+/fujVqxd69eoFc3NzuQcz5jgOSkpKqKqqwpMnT+Dn54dvv/0WK1aswJw5c6Ci8uaPfkeOHMHp06dx6dIldOzYseEnoYVijKGmpqbRCoXk/ejo6KB///64cuUK31HarNZ0zy9btgwnT57EokWLEBsb+8b/86h4RQhpUhzHAQAVrwj5P4wx7N69G19++SX09fVx5swZjBs3ju9YhBBCmoiBgQFcXFzg4uIis7ywsBAcx0m/0tLSEBcXhx07dqC4uBgAoK6uDgsLC5mCVq9evWBrawsTExOZ/WVmZkp7WtX2fMjOzsbnn3+OkJAQfPvtt/UWsSoqKvCPf/wD06dPx4gRI5rwTPBHV1cXDx484DsGIc2mNd3zAoEAGzduhJOTE/bt2wdfX99616PiFSGkSXEcB1VVVd4GLyWkJbl//z78/f0RGxuLBQsWYO3atdDW1uY7FiGEEB4YGBjA0dERjo6OdX725MkTZGZm4t69e9KvI0eOQCKR4M8//wQAGBkZwdLSElZWVrC0tMSdO3fq7Ke2iPX06VPMnz9fWsSaO3eu9JGePXv24NGjRzh//nzTNpgQQt5g4MCBmDlzJtasWfPG4hWNeUUIaVIcx8HU1JQGnibtWmVlJdatWwdbW1sUFBQgISEBYrGYCleEEELq1b17d4wZMwYBAQEICwtDdHQ00tPTUVpaivv37+PEiRP49ttvMWDAADx9+hQRERF48eLFG/f3155Y8+fPh5WVFaKiolBdXY3t27dj6tSpcg1+7uXlJTMY8197k507dw4CgQAxMTHSZYsXL5ZZv6qqClVVVdi3bx9cXV1hYmICTU1N2NnZQSwWv9cjTq8Pgi4QCJCbm4sjR47ILCsvLweAOsuzsrLg4+MDfX19dOzYEW5ubvX2XElPT4eXlxf09PSgpaWFwYMH49ixYxg3bpx0X35+fg1uh6Ln58WLF1iyZAksLCygrq6O7t27Y9y4cdi5cyfKysoavG5eXh6++OILmJmZQU1NDUZGRvD29pYZl+j1wfOTkpIwduxY6OrqQktLC6NHj0ZcXFyd9V+9eoW4uDjptq/3BpTn2LX+ej20tbUxYsSIRnkcUdG2KZK9Me69t7W1td3ztUQiEdLS0hAfH1//CoyQdmru3LnM1dWV7xht3pw5c9j48eP5jkF41p5fb/Hx8axfv35MU1OThYaGsqqqKr4jEUIIaWMePHjAAMj9JRAIGABmYWHBBAIBO3r0qNzH2rJlCwPAfvnlF5nls2bNYgCYj4+PzPLDhw+zsWPHSr+PiYlhANjatWtZQUEBy8vLY5s2bWJKSkps6dKldY7n4ODAunXr9s7lVVVVbMmSJczV1ZUVFBTUWd/T05MBYGVlZfUu9/T0ZPHx8aykpISdOXOGaWpqMicnJ5l17927x/T19Vm3bt3Y6dOnWXFxMUtNTWXjxo1jRkZGTF1d/S1n7n92797NALCff/65zs8UOT85OTnM3NycmZiYsJiYGPbHH3+w3NxcFhISwgCwDRs2NGjd7OxsZmpqyoyNjdnvv/8ubefIkSOZhoYGi4+Pl8nh4ODAtLW12dChQ6XnMCkpidnb2zM1NTV28eJFmfW1tbXZ8OHD6z03ihy7vutx69YtNn78eGZmZib39XgbRdqm6Hl733vvXW3l+55XVlZmQ4YMkftcM8aYpaUlCwwMrO9HJ6l4Rdqt9vxhujmNGjWKzZ8/n+8YhGft8fX26tUrFhgYyJSVldnIkSNZRkYG35EIIYS0UWfPnpW7aKWuri793sDAgAkEAnbw4EG5j/XixQumpqbGJk6cKF1WWlrKDAwMWO/evZmmpib7448/pD+bPHky27Vrl/T7mJgYNmrUqDr7nTlzJlNVVWVFRUUyy+UpXhUWFrIJEyYwkUj0xj8SveuDfExMjMzyqVOnMgAsLy9PumzatGkMAPvtt99k1n3+/DnT0tJqtOKVvOentmC4b9++OutPnDhRpiClyLqfffZZvQXKnJwcpq6uzhwdHWWWOzg4MADsxo0bMstv3brFADAHBweZ5W8rXily7Dddj6dPnzJ1dfVGK17J2zZFz1tj3Htvayvf93xDileff/75m+6Nk/TYICGkSXEcB3Nzc75jENKsjh8/jr59+yIiIgJbt27FhQsX0KdPH75jEUIIaaMePHhQ72yCampqUFL670e+2sd9AgICsH//fuTk5GDx4sXo3bs3vL295T6WoaEhPvroI5w5c0Y6Y2J0dDSGDBmChQsXoqysDIcOHQIAFBQU4OLFizL7d3Nzw4ULF+rs18HBAZWVlUhLS1Oo7RkZGRgyZAiUlJSwcePGBg9V4eTkJPN97Xit2dnZ0mUnT54EAEyYMEFmXSMjI1hbWzfouK9T5PwcPnwYAPDhhx/WWf/EiRNYvHhxg9Y9cuQIlJSU4ObmJrOeiYkJ+vXrh2vXruHJkycyP9PW1kb//v1lltnZ2aFr165ISUlBTk7OG9v8V4oc+03Xo2vXro36vkvetjXkvAHvd++9T1tbyj3/V/b29m/8P4CKV4SQJvPnn3/i6dOnNNMgaTeePXsGoVCISZMmYciQIUhPT4e/v7/c05wTQgghDZGVlYXq6mpp4UZTUxNDhw7F3/72N/z73/8Gx3F49eoVEhMTIRaLMW3aNJiYmCAvL6/OrIXyEAqFqK6uxr///W8AwO7duyEUCvHJJ59AWVkZv/zyCwBg7969cHNzg46OjnTboqIirFixAnZ2djAwMJCOmfPVV18BAEpLS+XOUVhYCC8vL3Tv3h0nTpzAnj17FG5LLT09PZnv1dTUAEA6zlRFRQWKi4uhoaEh055aBgYGDT72X8l7fioqKlBUVAQNDQ3o6uq+dZ8NWbempgZ6enp1xhG7fv06AODevXsy2+nr69e7v86dOwMAnj9//s62K3Lsd12P2uM2Bnna1tDzBrz/vdfQtraUe/6vjI2N8fLlS+nEFH9FxStCSJOpfSNFxSvSHhw4cAC2trY4d+4cDh06hP379zfqG6c3+fXXX6VvjDQ0NJr8ePV5fVDT9/H6gLv1vVlqSm8a5LQluXr1Ktzd3dG1a1d06NABw4YNg1gsRkFBQYP3uX//fggEAqirqzdi0raD7/siKChI5vjOzs7NenzS8mloaGD+/PmIjIzE7du3UVxcjPj4eISFhcHHx+eNveDLy8uhqamp8PEmTZoEQ0ND7N69G3l5eUhMTISXlxeMjY0xfvx4nD9/Hjk5Odi1axeEQqHMtu7u7ggJCcG8efOQmZmJmpoaMMawYcMGAP8dXF5eKioqOHv2LKKjo2FnZ4d58+YhKSlJ4fbIQ11dHbq6uigvL0dJSUmdn8tTnJGHvOdHXV0denp6KC8vR3Fx8TuzK7Kuvr4+VFRUUFlZKR3s//Wv0aNHy2z34sWLeq9d7Xn563uiN/1RT5Fjv+t6vM/vxNfJ07aGnjd5NGdbFTluY93zf6WlpQUAdSYQAKh4RQhpQhzHAQAVr0ibxnEcxo8fD19fX3h7eyM9PR2TJ09utuP7+vqCMYaxY8c2aPuSkhJYWlrW6eKuiKVLl4IxBgcHhwbv43U///wzGGMyb5YaI+u7eHl5gTEGT0/PJjvG+4iLi4OLiwtqamoQFxeHnJwciEQiBAYG4h//+EeD92tkZCTz7181x3lv6fi+L0JDQ6UffGj2XlKfFStWYOvWrZg9ezZsbW2b/D5RU1ODj48Pbt68ieXLl8PT01NaBPv0009RXV2NlStXIicnB2PGjJFuV11djbi4OJiYmOCLL76AkZGRtJBR34fVd9HV1UW3bt2go6ODo0ePQkdHB15eXnI/oqao2kfuah+lqpWbm4vMzMz33r+i56f2/cbx48fr/GzAgAH48ssvG7Sut7c3qqqq6p1Nb926dejZsyeqqqpklpeXl9cpHN6+fRvZ2dlwcHBAly5dpMu1tLRketZYWVkhIiJC4WO/6Xrk5+cjIyOjzvYNJW/bGnLe5NVcbZX3uI11zyuCileEkCbDcRwMDQ3f2NWWkNasqqoKYrEYDg4OyMnJQVxcHMLDw9/ZHb+lYYyhpqbmvaYnby6tKevb6OjoyEwvr4jt27ejqqoKGzduhLm5ObS1teHj44O5c+e+V6a3Fa+a87y/z7lp7dpz20nr9OmnnwIAIiMjZXpXeXl5QVdXF5GRkZgxY4Z0zC0AUFZWxqhRo5Cbm4v169cjPz8fZWVluHDhArZt2/ZeeczMzPDbb78hLy8P3t7eqKioeK/91Wft2rUwNDTE4sWLcebMGZSUlCA1NRWzZ89u0OOXr1P0/Hz//fcwNzfHl19+id9//x3FxcV48uQJFixYgJycHJmClKLrWlhYYM6cOThx4gSKiopQUFCA8PBwrF69GmFhYXXGWNPT08PXX3+NhIQEvHr1CsnJyZg5cybU1NQgFotl1h04cCAyMzPx+PFjJCQkgOM4jBgxQuFj13c97ty5g5kzZ76x5/bMmTMhEAggkUjkvi7ytq0h501eDWlrY2jqe14hCg39Tkgb0h5nP2tuS5cuZYMGDeI7BmkB2trr7ebNm8zJyYmpqqqywMBAVlFRwXckNnbs2EaZVed9vGlGKEW8bQam5vSmGXoaw9tmWXqX2pmMLl++3KiZcnNzGQDeX6fvc26aQ0u4LxoyexMhb+Ln58fGjx/f4O0tLS1Zz549WU1Njczy2pnt0tLS6myTl5fHAgICWI8ePZiqqiozNjZms2bNYkFBQdJZEB0dHdn69evrzJa4fPlytnfv3jrLN2zYwBISEuosnzFjBjt8+HC9y+tbf/ny5YwxVmf5pEmTpPkzMjKYl5cX69ChA9PS0mLDhg1jly5dYqNGjWJaWlpynbe3/a6T9/zUys/PZ4sXL2bm5uZMVVWVdenShfn6+rLMzMw6+1Zk3RcvXrAlS5awXr16MVVVVWZkZMTGjx/Pzpw5U2fd2t//d+7cYRMmTGC6urpMU1OTjRw5kl25cqXO+unp6WzEiBFMW1ub9ejRg23ZsqXBx/7r9dDU1GROTk7s2LFjbOzYsdLzNXfuXOn6Y8aMYTo6Om+clfJ92yZP9sa4997W1pZyzzfk99XJkycZAPby5cs6P6LiFWm32tqH6ZbI29ubffzxx3zHIC1AW3m9lZaWspUrVzJVVVU2fPhwdufOHb4jSVHxqnG1hCJFfaKjo6VTcxcXFzdapqqqKiYQCNj06dMbbZ8NQcUrKl6R5vW+xSvyP1ZWVqxnz55yrdtSftc1lsb4/d8cCgsLmaamJvPz85N7m9bSNj68655v7OIVPTZICGkyEomExrsibcbly5cxYMAAbNy4EevXr8fly5fRt2/fZs+Rnp4OLy8v6OnpQVtbGyNGjMCVK1fqrPf6ANMZGRn4+OOP0bFjR+my7du31zsI9evbZmVlwcfHB/r6+ujYsSPc3Nzw4MGDd2Z9ffB1gUAgnVZdUW8bMLuiogIrVqyAtbU1tLS0YGhoCHd3dxw9ehTV1dUNOl6t3Nxcudr+4sULLFmyBBYWFlBTU4OBgQE+/PBDmenOawe2f/XqFeLi4qRtUeQRAgsLC3To0AEpKSnw8PBotIHDlZWVYWBgUOexweY67/KeG3nOc0PWVVRLuy8IIc0jNzcXhoaGqKyslFmelZWFBw8eyIzvRVoWxhi++OILdOjQASEhIXzHaTVa1D2vcHmNkDairfQEacn09fVZeHg43zFIC9CaX2+FhYXM39+fCQQC5ubmxh49esRblnv37jF9fX3WrVs3dvr0aVZcXMxu3brFxo8fz8zMzOrteVXbU2TkyJHswoUL7NWrVywxMZEpKyuzvLw8mXVe701Su9zT05PFx8ezkpISdubMGWlX9de9/tfJqqoqtmTJEubq6soKCgrkauO7/hpdX1Y/Pz+mp6fHTp8+zUpLS1lubi5bunQpA8AuXLgg13HfdJy/tv3cuXOsQ4cOddqek5PDzM3NmbGxMYuJiWFFRUUsIyODeXt7M4FAwCIjI2XWb2jvovPnzzMtLS22ceNGaT43NzdWWVkpXWfSpEky3f6nTJki9/6trKzYmjVr6v1Zc533t50bRc6zotdEXi3hvqCeV6QxUc8rxeTk5DAAbPbs2ezRo0fs1atX7OrVq2zw4MHM0NCQPXjwQK791P6uq/3S1tZu4uRNqzX0TsrJyWHDhw9nqampCm3XGtrWlBS95wMDA2XubXpskJBG0Jo/TLcG+fn5DEC9z6aT9qe1vt6OHj3KunXrxkxMTNiuXbv4jsOmTZvGALDffvtNZvnTp0+Zurr6W4tXx48ff+N+31W8iomJkVk+depUBkBa/Kr11zd4hYWFbMKECUwkEsk9rgRjDStemZubs2HDhtVZt0+fPu9dvHq97dOnT6/T9tqxXfbu3Suzbnl5OevatSvT1NRkuZBBa9oAACAASURBVLm50uUNKV7l5eUxPT09NmHCBOm+x4wZwwAwX19fVl1dLV2X4zimqamp0HlnjLHhw4fzft7fdm4UOc+KXhN5tYT7gopXpDFR8UpxZ8+eZZMnT2ZmZmZMTU2NGRsbsxkzZrD79+/zHa3ZvWlcsragLbdNUc15z9Njg4SQZsdxHADQY4OkVcrOzoa3tzc8PT0xZswYpKamysykxJfaaYonTJggs7xr167o06fPW7cdPHhwg4/r5OQk832PHj0A/Pc81ScjIwNDhgyBkpISNm7c2ORTtk+cOBHx8fHw9/dHYmKi9JG1jIwMjBo16r32/Xrbu3XrBkC27YcPHwYATJo0SWZddXV1jB07FmVlZTh16tR75dixYweKioowY8YM6b6jo6MxePBg/Prrr5g/f7503YsXL8LFxUXh866ioqLQo2pNed7ro8h5bupr0lLuC0JI8xs7diwOHToEiUSCiooK5ObmYs+ePbCwsOA7WrNbunQpGGMyX2vWrOE7VqNoy21TVEu556l4RQhpEhzHQUVFRfohl5DWgDGGiIgIWFtb49atWzhz5gyioqLQsWNHvqOhoqLi/7N372FNXWn/8L+BQIAAARQVER8SrGBi1ap4ArSVoLVCRVpaf1VsZypBbS0Mjy20dsYeFa0nOqUO6jOt1R7G2mpFqwUcqWdHbVERQWFj8QBaC8SAEA5Z7x++ZAwBJEDYAe7PdXGZ7Ozsda+1N0Ju9roXNBoN7Ozsml0SuV+/fq2+XywWt7ttiURi8NzW1hYAoNPpjPYtLy9HeHg4Bg0ahP3792P79u3tbretUlJS8MUXX4DjOAQHB8PZ2RlPPvmkPnnQEU373rjke2PftVot1Go17Ozs4OTkZPT+/v37A0C7a301unz5ssHxAMDR0RH79+/H8OHDsXnzZvzv//4vGhoakJycjAULFnSovbYw57g3Zco4d8U5sZTrghBCCOktKHlFCDELjuPg5eUFGxsbvkMhpE1ycnIwadIkvPLKK1i8eDFycnIQHBzMd1h6IpEITk5OqKmpQWVlpdHrZWVlPERlTCgUIjMzEz/88AMeffRRREdH4/Tp02ZtUyAQICoqCpmZmaioqMDu3bvBGENERATWrVtn1rZFIhEkEglqamqg0WiMXr916xYAYMCAAQbxmqoxgXrp0iWD7W5ubkhPT4dMJsO6deswceJEiMViREZGmtxGVlaWSUkvc4x7S2Njyji355x0tq66LgghpCN+++03PP3007h7965+W2BgoNFiK41fcXFx7WonMTER//rXvzorbN40N15NffPNN/rxsrOz68LoWtcTzgElrwghZkErDZLuoq6uDqtWrcLYsWOh1Wpx6tQpJCUlWdQvHI1mzJgB4L/TBxvduXMH+fn5fIRkxMnJCZ6ennB0dMSePXvg6OiI8PBwlJSUmK1NFxcX5OXlAQBsbGwQEhKiXyVv3759Zmu30ezZswHAqC2tVouDBw/C3t7eYKqng4MDamtr9c99fX2xadOmNrWxfv16lJeXG7zm4eGBzMxMuLi44PTp01AqlV2SCDHHuLc2NqaMs6nnxBy64roghLRdZWUlHnnkEYSGhvIdikXIzs7G2LFjMW3aNDg7O5u1rejoaLz55pv461//atZ2zKmt4zVnzhwwxizqD6BAzzgHlLwihJgFx3GUvCIW79ixYxg1ahTee+89vPvuuzh9+jRGjx7Nd1gtWrFiBdzc3BAXF4eMjAxUVlYiNzcX8+bNa3YqId+8vb2xc+dO/P7774iIiIBWqzVbWwsXLsT58+eh1Wpx+/ZtrF69GoyxLlnCeeXKlZBKpYiLi8PevXuh0Whw+fJlvPDCCygpKUFycrLBdL/Ro0fj8uXLuHbtGk6cOAGO4xAUFNRqG+PHj0diYiJ+++03BAYG4scff0RVVRXu3buHY8eO4Y033oBYLIarqyvef/99bN261aQ+nD17Fn379kVgYGCz00Fb0tnj3trYmDLOpp4Tc+iK64IQYsjR0RGBgYHNvsYYg06nM+n/uO6qtXEAgLt37yIsLAzPPPMMXn31VaPXT58+bVTviTGGDRs2tCseHx8f7Nq1Cx9++CF27NjRrmPw6WHj1R1093MAALTaIOm1uuvqZ92FVCplK1as4DsMYiEs7ftNrVaz1157jVlZWbEZM2awq1ev8h1Sm+Xn57Pw8HDm7OzM7O3tmb+/P9u7dy8LDg7Wr4bz8ssvsxMnThitktP0x/6uXbuMXp87d26z721cYafp9pkzZ7Kvv/7aaPv69eubPc7cuXNb7V9Lqw22FCtjjGVnZ7OYmBg2bNgw5uDgwNzc3NiECRPY5s2bmU6nM2l8Te17ozt37rC4uDgmlUqZjY2NfmXAgwcPGrWRl5fHgoKCmFgsZl5eXiwlJaXN8e3du5c99dRTrG/fvkwoFDIXFxcWEBDA1q5dyzQaDTt+/DhzcHAwiLOuru6hxz19+rR+3B5cubCrxr3Rw8bGlHE2Zd+HsaTrglYbJJ2pp6022J7VXHuih43DsmXLmFAoZDdu3DB6LSAggJ0+fdoscUVGRrJBgwa16edSe4waNYolJSWx3377rVOP29p4tSQ4OLjZVaD5Zu5z0FGtrTYoYIyxzkuFEdJ9LFiwAMXFxUhPT+c7lB6nvr4e9vb22L59O55//nm+wyEWwJK+3/bu3YvFixejsrISSUlJUKlUfIdEHrB9+3ZERUVh48aNBivoEULuEwqFGDt2LE6ePMl3KKQHiI6ORnFxcY9Z+dLR0RGjRo3C0aNH+Q6FV62NA2MMHh4eGDJkSLOvBwYGYsOGDRg7dmynx/X111/jhRdewO7duzFr1qxOP/5TTz2F9PR06HQ6TJ48GXPnzkVkZCRcXFzafcyHjVdLlEoljh49ipqamna3bQ7mPgcd9dNPP+HJJ59ERUVF08VRfqJpg4SQTvfbb7+hvr6epg0Si1JaWor58+cjLCwMEyZMQH5+PiWuCCGEkB5gzZo1EAgEqKqqwrFjx/QFs4VCIQDo6/E1fjUmFJpu/+233/D888/DyckJffr0QVRUFMrLy3H16lWEhYXByckJHh4eiI6ObnYxht9//x2vvfYavL29YWtrC3d3d0RERCA7O9to3z/++APx8fHw8fGBra0tXF1dMWPGDBw6dEi/zwcffKCP7cFpgAcOHNBv79u3b5vHAQDOnTuHW7duYeTIkS2O57Zt2zBq1CiIxWJIJBIEBQXhq6++MtpPq9Xib3/7G/z8/ODg4AA3NzeEhYVhz549aGhoMNp/1KhRAGC2ZOmPP/6I69evY82aNbh79y5UKhUGDBiAiIgIfP/99+0qX/Cw8crLy0N4eDgkEgnEYjGCgoJaTXK15bybwsXFpcUC+1ZWVrh+/brB/uY+B+ZEyStCSKfjOA4AKHlFLAJjDF988QWGDx+Oo0eP4sCBA9ixYwfc3d35Do20YtGiRRAIBBZZy4uQrpaYmKj/MNLcB0JCerulS5eCMQaxWIyAgAB9jab6+noAQHh4OBhjRneaNN0eHx+PN954A6WlpdiwYQO2b9+OuXPnIi4uDu+//z5KSkrwzjvvYMuWLVi+fLnBsUpKSuDv748dO3bg008/RVlZGbKyslBWVoaJEyfixIkT+n1LS0vh7++Pr776CsnJybhz5w5OnToFBwcHBAcHY8uWLQCAt99+W9+vBz355JNgjGHMmDEmjQNwf3VlABg0aFCL41leXo5//vOfuH37Nv7zn/9AKpVi7ty5eO211wz2e/XVV/Hxxx/j73//O/744w9cunQJfn5+mDVrFo4cOWJ0XE9PT4MYzGHAgAGIj4/HL7/8gtzcXMTHx+Ps2bN45plnMGDAAERHRyMrKwttnYDW2ngVFBRg4sSJOHPmDHbu3Ilbt27h008/xfvvv4/CwkKj/dt63k2l0WgMapO99957AIAPP/zQKO6uOAdmY/ZJi4RYKEurwdOT/OMf/2ASiYTvMIgF4ev7raCggCmVSmZlZcVUKhXTaDRdHgOxDGim/lfTr+XLl/MdZo9j6eNu6fERYm69rebVrFmzGABWXV3d7PZ9+/YZbFcoFAwA+/nnnw22S6VS5uvra7DtxRdfZADYl19+abC9pKSEiUQiNmbMGP22l156iQFgX3/9tcG+NTU1bODAgcze3p6VlpY+tF9jxoxhffr0Mdre2jisXr2aATCp3iJjjI0bN44BYCdPntRvk0qlbNKkSUb7Dh06lB06dKjZ4wgEAjZkyBCT2u4onU7HsrKy2IIFC5iLiwsDwEaMGNGm97Y2XpGRkQwA27lzp8H2GzduMJFIZFTzytTz3hYSicTg99t//etfTCAQsJdeeqnF9/BxDtqqtZpXdOcVIaTTFRUV0V1XhFf19fVITk7GyJEjcfv2bZw4cQKpqal0F08vxppZNanp1zvvvMN3mD2OpY+7pcdHSG+Vk5NjNAWqK1Z5a1rnaeDAgc1u9/T0xM2bNw227d69G1ZWVggNDTXYPmDAACgUCpw9e1Y/hWvXrl0AgJkzZxrsKxKJEBwcjOrqarNN62qcMmljY2PS+5599lkAQFpamn7bk08+iePHj0OlUuHkyZP6O0Pz8/Px+OOPN3scoVCI6urqdkTe/utCIBDAzs4OdnZ2Jve7tfE6cOAAAGD69OkG2wcOHIihQ4ca7W+O815RUaH//fbUqVN48cUXMXnyZKSmprb4no6cAz4JH74LIYSYhuM4Sl4R3mRnZ2PBggW4ePEiEhIS8NZbb8HW1pbvsAghhBCLIxaLce/ePb7DMDJ8+PA2T+vqTM7OzgbPraysYG1tDQcHB4Pt1tbW0Ol0+udarRZqtRoAmhaZNnDlyhW4u7tDrVbDzs4OTk5ORvv0798fwP0pZuZgZ2cHAKirqzPpfR4eHgCA27dv67elpKRg4sSJ2Lp1K4KDgwEAQUFBiImJwezZs5s9TuPCTu1h6nVx+fJlfPnll/jyyy9RWFgIFxcXPPPMM5g7d26LybWmWhovrVYLjUYDOzu7Zv842q9fP1y+fNlgf3Oe9+LiYsyaNQteXl74/vvvW/3dtyPnwNwqKyshEAiMpsoCVPOKEGIGlLwifLh37x4SExMxduxYODg44Ndff8U777xDiStCCCGkBe7u7igpKeE7jE4jEAh4aVckEsHFxQVCoRB1dXUt3sn5xBNPQCQSQSKRoKamptmi77du3QJw/46tRlZWVqitrTXat6Kiotl4WhuHxiRUY7KtrRrvNOvXr59BO1FRUcjMzERFRQV2794NxhgiIiKwbt06o2PcvXtXv3qfudy6dQsff/wxxo0bB19fXyQlJeHRRx/Fzp07UVpaii1btuCJJ55o87XS0niJRCI4OTmhpqYGlZWVRu8rKysz2t/U895WGo0GoaGhqKurw969e+Hm5tbivl1xDjri1q1bcHNzM1hkoBElrwghnY7jOEilUr7DIL1IVlYWRo0ahdTUVKxduxZZWVnw8/PjOyxCCCHEog0fPhxFRUW4e/cu36F0CgcHB4Mkj6+vLzZt2tQlbUdERKC+vh7Hjh0zem3VqlUYPHiwvnB6411J+/btM9hPq9Xi4MGDsLe3N5iK5uHhgRs3bhjsW1paiuLi4mZjaW0chg8fDgBGq9ABwJYtW4yKwAP3p1jv2LEDABAWFqbf7uLigry8PAD3p9WFhIToV3Bs2jcA+j40xtDZZs6cCU9PT8TFxcHe3h6pqakoLS3Frl278Mwzz0AkEpl8zNbGa8aMGQD+O32w0Z07d5Cfn2+0v6nnvS0aGhowZ84c5OXl4bvvvjOYrvjss89i9+7dBvub+xx0VHZ2NhQKRbOvUfKKENKpKioqUF5eTndekS5RXl6OmJgYTJ06Fb6+vsjJyUFsbCysrOjHGyGEEPIwQUFBEAgEyMzM5DuUTjF69GhcvnwZ165dw4kTJ8BxHIKCgrqk7ZUrV8LHxwd//vOfsX//fqjVapSVlSE1NRXvvfce1qxZo7+bZOXKlZBKpYiLi8PevXuh0Whw+fJlvPDCCygpKUFycrJ+GhkATJs2DTdv3sQnn3yCyspKFBYWIjY21uAuqLaOw8iRI9GvXz+cO3eu2ff+8ssveOWVV1BQUICamhrk5+cjKioKZ8+exZIlSzB+/HiD/RcuXIjz589Dq9Xi9u3bWL16NRhjmDp1qtGxs7Oz9f0xh5s3b+KDDz7A1atX8fPPP0OlUsHV1bVDx2xtvFasWAE3NzfExcUhIyMDlZWVyM3Nxbx585qdSmjqeW+Lv/zlL/jxxx+xadOmNk2FNPc56KiMjAxMmTKl+Rc7szI8Id0JrTZoHmfOnGEA2OXLl/kOhVgQc3y/7dixg7m7uzMPDw+jVV4IIYQQ0jaTJ09mzz77LN9hdIq8vDwWFBTExGIx8/Ly0q8Qt2vXLqOVROfOnctOnDhhtH3ZsmXs9OnTRttXrlzJjhw50uqKpH/88QeLj49nMpmM2djYMHd3dzZt2jSWkZFhFOudO3dYXFwck0qlzMbGhkkkEjZ9+nR28OBBo30rKirYggULmIeHB7O3t2eBgYHs9OnTbMyYMfo4EhISHjoOjd566y0mFArZjRs3DLbX1NSwb7/9ls2ePZv5+PgwkUjEJBIJe/zxx9lXX31lFFd2djaLiYlhw4YNYw4ODszNzY1NmDCBbd68mel0OqP9IyMjmaenJ6utrW39RFqYlsaLMcby8/NZeHg4c3Z2Zvb29szf35/t3buXBQcH68/Nyy+/rN/flPP+MI2fu1r72rVrl8F7LPkcHDt2jAFgp0+fbu7lAwLGeKiER4gFWLBgAYqLi5Gens53KD3Kt99+izlz5uDevXvtujWX9Eyd+f129epVLFy4EOnp6YiOjsZHH31kVGCVEEIIIW2zfft2/PnPf0ZeXh7dOd9LqNVqKBQKhIaG4h//+EeXtHnu3Dk89thj+OqrrzBnzpwuabOz8DFe5mDp5+C5555DQUEBfvnll+Ze/onmVRBCOhXHcfDy8qLEFel0Op0OmzZtwogRI1BYWIiDBw8iNTWVEleEEEJIB8yZMwd+fn5YunQp36GQLiKRSJCWloadO3ciJSXF7O1xHIeIiAi8+eabFpk0eZiuHi9zsPRzcOzYMezcuRPvvvtui/tQ8ooQ0qmKioror3ak0124cAGTJk3Cq6++isWLFyMnJwdPPPEE32ERQggh3Z5QKMT69euxa9cu/PTTT3yHQ7rIY489hjNnzmD//v1mL9ifmpqKDz/8EB9++KFZ2zGnrhwvc7Dkc6DT6RAXFwelUmmwIEBTxusPEkJIB3AcR8kr0mlqamqQlJSElStXYsyYMfj1119bXIGEEEIIIe0THByM2bNnIzo6GqdOnYKHhwffIZEu4O3tjb1795q9nVWrVpm9ja7QVeMlEAgeus/y5cvxzjvvtPmYlnwO3nrrLVy4cEFfTL4llLwihHQqjuNaXiGCEBMcPXoU0dHRKC4uxnvvvYelS5fC2tqa77AIIYSQHunzzz/HpEmTEBoaisOHD0MsFvMdEiG9Um8qS/75559j9erV2Lp1K/z8/Frdl6YNEkI6TUNDA4qLi+nOK9IharUasbGxmDJlCmQyGS5duoSEhARKXBFCCCFm5OzsjN27d+O3337D888/j6qqKr5DIoT0YN999x1iYmLw1ltvISoq6qH7U/KKENJpiouLUVdXR8kr0m5paWkYPnw4/vWvf+Gzzz7Dvn37MHjwYL7DIoQQQnqFIUOGYN++ffjPf/6DoKAgXL9+ne+QCCE9UFJSEp577jmoVCq8//77bXoPJa8IIZ2G4zgAoOQVMVlJSQkiIyPx9NNPY+LEicjJycH8+fP5DosQQgjpsXQ6XbPJqfHjx+PUqVOora3F+PHj8d133/EQHSGkJ7px4wYiIyPx9ttvIzk5GX//+9/bVOMLoJpXhJBOxHEcHB0d4e7uzncopJtgjGHbtm34y1/+AhcXF6SnpyMkJITvsAghhJAeo7a2FleuXEFubi44jsPFixeRm5uLvLw86HQ6VFZWwsrK8J4GqVSKY8eOITY2FpGRkXjiiSewbt06jBw5kqdeEEK6s6qqKiQnJ2PFihUYMGAADhw4AKVSadIxKHlFCOk0RUVF8PHx4TsM0k0UFBQgJiYGhw8fxuLFi7FixQoqDksIIYS0U2lpKS5duoT8/HxcunQJeXl5yM/PR3FxMRhjsLGxgUwmw7Bhw6BUKvHqq69i2LBhLR5PIpHg888/x6JFi7BkyRKMGjUKkydPRmRkJIKDgzF06FCqR0kIadGdO3dw6tQppKWl4ZtvvkFDQwOWLVuG+Ph4iEQik49HyStCSKfhOI6mDJKHqqurw7p167B8+XL4+fnh+PHj8Pf35zssQgghxOLV19ejuLjY4A4qjuNw4cIF3Lp1C8D9pNOQIUMgk8nw0ksvQaFQQCaTQS6Xw97e3uQ2x48fj5MnTyIzMxP/93//h2XLlmHJkiUQiURwc3Nr1zEJIT2XTqdDeXk51Go1BAIBRo8ejbfffhsvvfQS+vbt2+7jUvKKENJpOI7D5MmT+Q6DWLBffvkF0dHRuHTpEhITE7Fs2TLY2NjwHRYhhBBiUdRqNQoKCoySVLm5uaiurgYAuLq6Qi6XQ6FQQKlU6h9LpdI215BpKysrK0ybNg3Tpk1DXV0dLly4gNzcXJSVlenjIYQQABAIBHBxcYG3tzdGjRqFfv36dcpxKXlFCOk0HMfhxRdf5DsMYoHq6+tx5coVjBs3DgEBAcjOzsbQoUP5DosQQgjhVXl5uT459WCSqqioSD/Vz8vLC3K5HEqlEiqVCnK5HCNHjoSTkxMvMdvY2GD06NEYPXo0L+0TQnonSl4RQjqFRqPBH3/8QdMGiZEff/wR3333HWpqavDpp58iOjq60/8iTAghhFiquro6XLt2zSA5dfHiRZw/fx4ajQbA/buoGqf2KZVK/WM/Pz+qK0UIIaDkFSGkkxQWFgIAJa+I3u3bt7F06VJs27YNUqkUgwcPhkql4jssQgghxCzKy8uNpvldvHgR+fn5aGhoAAB4eHhAoVBAoVAgMjJS/9jDw4Pn6AkhxLJR8ooQ0ik4joOVlRX+53/+h+9QiAX49ttvsXjxYtja2uL777/Hvn37UFxczHdYhBBCSIfdvHnTIDnVOOWvpKQEACASieDj4wOFQoGwsDAkJCRAoVBg2LBhcHBw4Dl6Qgjpnih5RQjpFBzHwdPTE3Z2dnyHQnhUVFSEhQsXIiMjA9HR0VizZg2cnJywb98+vkMjhBBC2kyr1aKgoMAoSXXp0iXcu3cPQMsF0729vWFlZcVzDwghpGeh5BUhpFMUFRVBKpXyHQbhSX19PVJSUvD222/D29sbx48fx4QJE/gOixBCCGnVgwXTH0xSXb16FTqdTl8wXSaTISAgQF8wfcSIEXB2duY7fEII6TUoeUUI6RQcx1G9q17q/PnzWLBgAbKzsxEfH493330XIpGI77AIIYQQAP8tmN50mt+FCxdw9+5dAICLiwt8fHwgk8kQFRUFhUIBmUwGhUJBd5UTQogFoOQVIaRTcByHiRMn8h0G6ULV1dVYtWoVVq5cCX9/f5w7dw7Dhg3jOyxCCCG9VEVFBQoLC5stml5TUwOg+YLpMpkMUqmUVsIlhBALRskrQkiH6XQ6/Pbbb3TnVS9y+PBhqFQqlJaWYvXq1ViyZAnV9yCEENIlmiuYznEcioqKwBiDra0tBg0aBLlcDqVSqZ/qN2rUKDg6OvIdPiGEkHag5BUhpMOuX78OrVZLyateoKKiAgkJCdi8eTNmzpyJjIwMeHl58R0WIYSQHqa2thbXr183mOaXm5uL/Px8VFZWArhfMF0mk+mTVI2P/fz8YG1tzXMPCCGEdCZKXhFCOozjOACg5FUPl5aWhkWLFqGhoQGff/455s+fz3dIhBBCurny8vJmp/nl5+ejoaEBQqEQgwcPNiiYLpPJMHz4cAwYMIDv8AkhhHQRSl4RQjqM4zg4ODigf//+fIdCzODmzZtYsmQJdu3ahXnz5mH9+vXo06cP32ERQgjpJurr61FcXGyUpMrJyUFpaSkAQCQSwcfHBwqFAmFhYUhISIBCocCwYcPg4ODAcw8IIYTwjZJXhJAOKyoqgkwmo0KnPQxjDJs3b8brr78Od3d3ZGRkIDg4mO+wCCGEWCitVouCggKjelS5ubmorq4GcH+qn1wuh0KhgFKp1D/29vam2omEEEJaRMkrQkiHcRxHUwZ7mCtXrkClUuHo0aNYvHgxVqxYAbFYzHdYhBBCLEB5ebnRNL/c3Fx9wXQbGxt4eXkZFUwfMWIEnJ2d+Q6fEEJIN0TJK0JIh3EchwkTJvAdBukEdXV1WLduHZYvXw65XI6TJ09izJgxfIdFCCGki9XV1eHatWtGSaoLFy7g7t27AAAXFxf4+PhAJpMhKioKCoUCcrkcvr6+EArpYwYhhJDOQz9VCCEdxnEc/t//+398h0E66Pjx44iOjsbVq1fx7rvvYunSpbRaEyGE9HAVFRUoLCw0uIPq4sWLuHz5Murr6wEAHh4eUCgUUCgUiIyMhEKhgEwmo7uuCSGEdBlKXhFCOqSyshK3b9+mX2C7sbt37+Kvf/0rPvnkE0ybNg379u2Dt7c332ERQgjpRDdv3jSa5sdxnH7FYFtbWwwZMkRfML2xFpWfnx9NGyeEEMI7Sl4RQjqk8ZdeSl51T/v27cOiRYtQWVmJjRs3QqVS8R0SIYSQdqqtrcWVK1eMklR5eXmoqqoCcL9gukwm09ejanw8bNgwKphOCCHEYlHyihDSIRzHQSAQ0J063cytW7fw+uuvY9u2bYiMjERKSgrc3d35DosQQkgblJeXG03zy83NxdWrV6HT6SAUCjF48GDIZDIEBARApVJBJpPh0UcfRf/+/fkOnxBCCDEZJa8IIR3CcRw8PDzg4ODAdyikDRhj2LZtG+Lj4+Hk5IQDfewIXwAAIABJREFUBw5g+vTpfIdFCCGkifr6ehQXFxtN87tw4QJu3boFAJBIJBgyZIhBwfTGO6ns7e157gEhhBDSeSh5RQjpkKKiIpoy2E1wHIeYmBj8+9//xoIFC7B27Vo4OjryHRYhhPRqarUaBQUFRkmq3NxcVFdXA7g/1a+xBpVSqdQ/lkqlEAgEPPeAEEIIMT9KXhFCOoTjOEpeWbj6+nqkpKRg2bJlkMlkOHHiBMaNG8d3WIQQ0quUl5cbJKcaHxcVFYExBhsbG3h5eelrUalUKsjlcowcORJOTk58h08IIYTwipJXhJAO4TgO/v7+fIdBWpCdnY3o6Gjk5OQgISEBb731FmxtbfkOixBCeqS6ujpcu3bNKEl1/vx5aDQaAIYF0xtrUcnlcvj5+cHa2prnHhBCCCGWiZJXhJB2Y4zh6tWrdOeVBaqursa7776LNWvWYNKkSfj111/h5+fHd1iEENIjNC2Y3vg4Pz8fDQ0NAAAPDw8oFAooFApERkbq61HRz0xCCCHEdLQeLiGk3W7cuIGamhr6RdzC/Pzzzxg5ciRSU1Oxdu1aZGVlUeKKEELa4ebNm8jMzMSmTZsQGxuLkJAQDBw4EG5ubhg7diyio6ORlpYGAAgLC8M///lPnDlzBlVVVbh58yYyMjKQmpqK2NhY3LlzBz4+PhAIBLCzs+OlP2vWrIFAIIBAIMCgQYM6dKzt27frjyUQCLq8huLu3bsN2q+pqenS9tvi1KlTCAsLw8CBA+Hs7IxJkyYhOTkZZWVl7T7mjh07IBAIIBKJOjHSnoPv6yIxMdGg/QkTJnRp+4T0ZJS8IoS0G8dxAEDJKwtRXl6OmJgYPPHEE/D19cWFCxcQGxsLKyv6r54QQlqi1Wpx8eJFfPvtt1i1ahXmz5+PsWPHQiwWw9PTEyEhIUhMTMTZs2chk8kQGxuLPXv2oLCwENXV1bh48SJ27NiBpKQkzJ8/H2PGjGl2Bd45c+aAMYbg4OB2xVlZWYlHHnkEoaGh7e7r0qVLwRjDyJEj232MpjZu3AjGGCorK/XbOiPWhwkPDwdjDLNmzTJbGx1x7NgxBAYGQqfT4dixYygpKUFsbCwSEhLwxhtvtPu47u7uBv8+qCvG3dLxfV0kJSWBMQbGGE0DJqST0bRBQki7cRwHOzs7eHh48B1Kr/ftt9/ilVdegVAoxLfffotnnnmG75AIIcSitFQw/erVq9DpdBAKhRg8eDBkMhkCAgL09ahGjBiBfv368R0+GGPQ6XTQ6XR8h/JQ3SnW1jg6OmLUqFE4evSoye/dsmUL6uvrsWHDBkilUgDA888/j8OHD0Or1bY7ptaSV1057h0Zm+6uN/edED5R8ooQ0m5FRUWQyWS0TDePbty4gVdffRU//PAD5s2bhw0bNsDNzY3vsAghhBeNBdOb1qM6f/48bt++DQCQSCQYMmQIZDIZoqKi9LWoFAoFb9P52sLJyQmFhYV8h9Em3SlWc2GMAQBKS0vxyCOP6LenpKR06LitJa9o3AkhPRklrwgh7cZxHE0Z5IlOp8OWLVuwdOlS9O/fHwcPHsQTTzzBd1iEENIl1Go1CgoKmi2a3ljjprFgukwmQ2hoqP6xVCqlP7oQs4uIiMDWrVuxZMkSHD16tNNqgvXt2xcCgaDZ5BUhhPRkVAiFENJulLzix4ULFzBp0iS8+uqrWLx4MXJycihxRQjpkZormO7j4wNXV1eMHTsW8+bNw7Zt21BdXQ2lUonk5GQcOXIEGo3GqGC6Uqns0ruF8/LyEB4eDolEArFYjKCgoGanGTUtMJ2fn4/nnnsOffr00W/bsmVLs0Wom7736tWreP755+Hi4oI+ffogNDS0TXfiNC2+LhAIUFpa2q5+t1YwW6vV4m9/+xv8/Pzg4OAANzc3hIWFYc+ePfpVGturtLS0TX3/448/EB8fDx8fH9ja2sLV1RUzZszAoUOH9Ps0FravqqrCsWPH9H0RCtv+d38fHx84Ozvj3LlzePrppzutcLi1tTVcXV2NklddNe5tHZu2jHN79jWVpV0XhJAOYIT0Ui+//DILCQnhO4xubcCAAWz9+vV8h9FrVFdXs+XLlzNbW1s2ceJElpOTw3dIbUbfb4SQlmi1WlZYWMj27NnDkpKSmEqlYgEBAczR0ZEBYACYq6srGzNmDIuKimJJSUlsx44dLCcnh9XX1/MdfrOuXLnCXFxcmKenJ0tPT2cajYadP3+eTZs2jXl7ezORSGT0nlmzZjEAbMqUKezQoUOsqqqKnTx5kllbW7Pff//dYJ/q6upm3ztr1ix2/PhxVllZyTIyMpi9vT3z9/c3amvkyJHM09NT/7y+vp7Fx8ezkJAQVlZW1qY+btu2jQFgGzdubPb15mJdsGABk0gkLD09nd27d4+VlpaypUuXMgDs0KFDbWq3pXYe7PvBgweZs7OzUd9LSkqYVCpl/fv3Z2lpaUytVrP8/HwWERHBBAIB27x5s8H+YrGYBQQEmBzTv//9b+bg4MA2bNigjy80NJTV1dXp95k5c6b++gbAnnnmmTYf39fXl33wwQfNvtZV497a2Jgyzqaek7ayhOvC2tqajR8/vl3xE0KMHKDkFem16MN0x1RVVTGBQMB++OEHvkPpFY4cOcKGDRvGHBwcWFJSksV+YGsJfb8RQsrKytiZM2fY1q1bWUJCAouMjGRyuZxZW1vrP8B7eHgwpVLJXnvtNZaamsoyMjJYSUkJ36GbLDIykgFgO3fuNNh+48YNJhKJWk1e/fjjjy0e92HJq7S0NIPtzz77LAOgT341ejB5VV5ezqZPn85iY2NN+tnSnuSVVCplkyZNMtp36NChHU5eNe37Cy+8YNT3l156iQFgX3/9tcG+NTU1bODAgcze3p6Vlpbqt7cnefX7778ziUTCpk+frj/21KlTGQA2Z84c1tDQoN+X4zhmb29v8s/0gIAA3se9tbExZZxNPSdtZQnXBSWvCOlUB2jaICGkXYqKisAYo2mDZqZWqxEbG4spU6ZAKpXi0qVLSEhIoOWXCSEWqb6+HhzHITMzE8nJyYiJiUFISAg8PDzg5uaGsWPHQqVSIS0tDQAQFhaGf/7znzhz5gyqqqr0U/2Sk5OhUqmgVCoxYMAAnntlugMHDgAApk+fbrB94MCBGDp0aKvvHTduXLvb9ff3N3ju5eUF4P70y+bk5+dj/PjxsLKywoYNG8z+s+XJJ5/E8ePHoVKpcPLkSf2Utfz8fDz++OMdOnbTvnt6egIw7PuuXbsAADNnzjTYVyQSITg4GNXV1fjpp586FMdnn30GtVqNuXPn6o/9ww8/YNy4cfjmm2+wcOFC/b5ZWVkIDAw0edyFQqFJU9XMOe7NMWWczX1OLOW6IIR0HE3QJYS0C8dxAABvb29+A+nB0tLSsHjxYtTV1eGzzz7D/Pnz+Q6JEEIA3K+hU1BQYFAoPTc3F5cuXcK9e/cAAK6urpDL5VAoFFAqlfrH3t7esLLquX8/1Wq10Gg0sLOza7ZId79+/XD58uUW3y8Wi9vdtkQiMXhua2sL4P4iH02Vl5cjPDwcgwYNwv79+7F9+3bMmzev3W23RUpKCiZOnIitW7ciODgYABAUFISYmBjMnj27Q8du2vfGa6yx71qtFmq1GnZ2dnBycjJ6f//+/QGg3bW+GjWe28bjAYCjoyP279+PKVOmYPPmzXBycsLq1auRnJyMt956q0PttYU5x70pU8a5K86JpVwXhJCOo+QVIaRdOI7DgAEDOm31HPJfpaWlWLJkCXbu3InIyEh8+umn6Nu3L99hEUJ6ofLycqPV/HJzc3H16lXodDrY2NjAy8sLcrkcSqUSKpUKcrkcI0aMgLOzM9/h80IkEsHJyQkajQaVlZVGPyfLysp4isyQUChEZmYmJBIJJk2ahOjoaPj6+hrdqdKZBAIBoqKiEBUVhbq6OmRlZWHNmjWIiIjA2rVrER8fb7a2RSIRJBIJ1Go1NBqNUaLi1q1bAGBwp197ivv36dMHAHDp0iVMmzZNv93NzQ3p6ekIDAzEunXrcOTIEYjFYkRGRprcRlZWlkn7m2PcWxobU8a5Peeks3XVdUEI6bie+2cvQohZFRUV0ZTBTsYYwxdffAGFQoFffvkF6enp2LFjByWuCCFmVVdXB47jkJaWhlWrViEmJgaBgYGQSCRwc3NDUFAQEhISkJmZCXt7e0RFReGbb77BmTNnoNFoUFhYiLS0NCQlJUGlUiEwMLDXJq4azZgxA8B/pw82unPnDvLz8/kIyYiTkxM8PT3h6OiIPXv2wNHREeHh4SgpKTFbmy4uLsjLywMA2NjYICQkRL9K3r59+8zWbqPGu4yatqXVanHw4EHY29sbTPV0cHBAbW2t/rmvry82bdrUpjbWr1+P8vJyg9c8PDyQmZkJFxcXnD59GkqlsksSIeYY99bGxpRxNvWcmENXXBeEkI6jO68IIe3CcRwlrzpRQUEBYmJicPjwYSxevBgffvgh3dVGCOlUFRUVKCwsNLiDiuM45OTkQKvVArj/4VqhUEChUCAyMhIKhQIymYz+vzfRihUrkJmZibi4OEgkEkycOBHFxcWIj4+Ho6Mj1Go13yEa8Pb2xs6dOxESEoKIiAhkZWVBJBKZpa2FCxfi448/hq+vL9RqNTZu3AjGGKZOnWqW9h60cuVK/Pzzz4iLi4OjoyOmTJmCkpISvPnmmygpKUFqaqrBdL/Ro0fjxIkTuHbtGq5fvw6O4xAUFNRqG+PHj0diYiKSkpIQGBiIjz76CFOmTIFAIMCvv/6KDRs2QCwWQyAQ4P3334dMJsOLL77Y5j6cPXsW06dPh5+fHw4fPtzmKbidPe6tjY0p42zqOTGHrrguCCGdgN+C8YTwh1Y/6xiFQsH++te/8h1Gt1dbW8uSkpKYnZ0dGzlyJPvPf/7Dd0hmQd9vhHSdGzdusIyMDJaamspee+01plQqmUwm06/oZ2try+RyOYuMjGQJCQls69at7MyZM6yyspLv0HuU/Px8Fh4ezpydnZm9vT3z9/dne/fuZcHBwfpz8fLLL7MTJ07onz/49aBdu3YZvT537txm37ts2TLGGDPaPnPmTPb1118bbV+/fn2zx5k7d26r/WtptcGWYmWMsezsbBYTE6NfPdfNzY1NmDCBbd68mel0OpPG19S+N7pz5w6Li4tjUqmU2djY6FcGPHjwoFEbeXl5LCgoiInFYubl5cVSUlLaHN/evXvZU089xfr27cuEQiFzcXFhAQEBbO3atUyj0bDjx48zBwcHgzjr6uoeetzTp0/rx+3BlQu7atwbPWxsTBlnU/Z9GEu6Lmi1QUI61QEBY4x1WiaMkG5kwYIFKC4uRnp6Ot+hdDuMMTg6OuKTTz7Bn/70J77D6bZ+/fVXLFiwAJcuXcIbb7yBZcuWwcbGhu+wzIK+3wjpXLW1tbhy5YpRLaq8vDxUVVUBuF8wXSaT6QulNz4eNmxYjy6YTrrG9u3bERUVhY0bNxqsoEcIuU8oFGLs2LE4efIk36EQ0hP8RNMGCSEmKy0txb1792gaSTvdu3cP7733HtasWYOAgAD8+uuv8PX15TssQogFKi8vN5rmd/HiReTl5UGn00EoFGLw4MGQyWQICAiASqWCTCbDo48+avapNoQQQgghXYWSV4QQk3EcBwCUvGqH/fv3Y9GiRVCr1fj0008RHR1Nq9YQ0svV19ejuLjYKEl14cIF/UpXIpEIPj4+RrWo5HI57O3tee4B6c0WLVqERYsWQSwWo7Kyku9wCOFVYmIiVq1axXcYhPRIlLwihJiM4ziIRCJ4enryHUq3UVZWhjfffBObNm1CaGgoUlNTMXDgQL7DIoR0IbVajYKCAqMkVW5uLqqrqwHcn+rXOM1PqVTqH0ulUkp0E4syb948zJs3r9OP25brfPny5XjnnXc6ve3ezNLH3dLja5SUlISkpCReYyCkp6LkFSHEZBzHwdvbm2qmtNG3336LxYsXw9bWFt9//71+SWZCSM9UXl5uNM0vNzcXRUVFYIzBxsYGXl5ekMvlUCqVUKlUkMvlGDlyJJycnPgOnxBeUTleflj6uFt6fIQQ86PkFSHEZEVFRTRlsA2KioqwcOFCZGRkIDo6GmvWrKEPpoT0EHV1dbh27ZpRkur8+fPQaDQADAumN9aiksvl8PPzg7W1Nc89IIQQQgjpPih5RQgxGcdxGDFiBN9hWKz6+nqkpKTg7bffhre3N44fP44JEybwHRYhpB1aKpien5+PhoYGAICHhwcUCoVRPSpK8hNCCCGEdA5KXhFCTMZxHGbNmsV3GBbp/PnzWLBgAbKzsxEfH493330XIpGI77AIIQ9x8+ZNo2l+HMfpF6iwtbXFkCFDoFAoEBYWhoSEBCgUCvj5+UEsFvMcPSGEEEJIz0bJK0KISWpqalBSUkJ3FDRRXV2NVatWYeXKlfD390d2djbkcjnfYRFCHlBbW4srV64YJany8vJQVVUFoOWC6VTnjxBCCCGEPyb9FvbNN99AIBBAIBDAzs7OXDG1as2aNfoYBg0a1KFjbd++XX8sgUAAR0fHToqybXbv3m3Qfk1NTZe23xanTp1CWFgYBg4cCGdnZ0yaNAnJyckoKytr9zF37NgBgUBAd6O0gO/rIjEx0aD9ptPdioqKoNPpKHn1gMOHD+Oxxx7D+vXrsXr1ahw+fJgSV4TwqLy8HEePHsWmTZuQmJiIsLAw+Pj4wN7eHsOHD8cLL7yATZs2oaSkBAEBAVi3bh0yMjJw69YtlJWV4ejRo0hNTUVCQgLCwsIgk8kocUUIIYQQwiOTfhObM2cOGGMIDg5uV2OVlZV45JFHEBoa2q73A8DSpUvBGMPIkSPbfYymNm7cCMYYKisr9ds6I9aHCQ8PB2PMYqdfHTt2DIGBgdDpdDh27BhKSkoQGxuLhIQEvPHGG+0+rru7u8G/D+qKcbd0fF8XSUlJYIyBMdZsQeHGKTRSqbSrQ7M4FRUViImJweOPP45HHnkEOTk5iI2NpQ+5hHSB+vp6cByHzMxMJCcnIyYmBiEhIejfvz/c3NwQFBSEN954A5mZmbC3t0dUVBS++eYbnDlzBhqNBoWFhcjIyEBycjJUKhWUSiX69evHd7cIIYQQQkgzunTaIGMMOp0OOp2uK5ttl+4Ua2scHR0xatQoHD161OT3btmyBfX19diwYYM+UfH888/j8OHD0Gq17Y6pteRVV4771q1bu/xuO0vRkeuC4zi4u7vD2dnZDJF1H2lpaVi0aBEaGhrw+eefY/78+XyHREiPpFarUVBQ0GzR9MY7Ux+c6hcaGqovmC6VSiEQCHjuASGEEEII6aguTV45OTmhsLCwK5tst+4Uq7kwxgAApaWleOSRR/TbU1JSOnTc1pJXNO6Wr6ioqFdPGSwpKcGrr76KXbt2Yd68eVi/fj369OnDd1iEdHstFUwvKioCYwy2trYYNGgQ5HI5lEolVCoV5HI5Ro0a1Wv/EEEIIYQQ0ltQwXbSooiICGzduhVLlizB0aNHO+3DQd++fSEQCJpNXhHL0/QuOI7jemXyijGGzZs34/XXX4e7uzvS09OhVCr5DouQbqW2thbXr183uoPq3Llz+qn7rq6ukMlk+iRV42M/P79mpzITQgghhJCer9XCLHl5eQgPD4dEIoFYLEZQUFCz04yaFpjOz8/Hc889hz59+ui3bdmypdki1E3fe/XqVTz//PNwcXFBnz59EBoa2qY7cZoWXxcIBCgtLW3XoLRWMFur1eJvf/sb/Pz84ODgADc3N4SFhWHPnj1oaGhoV3uNSktL29T3P/74A/Hx8fDx8YGtrS1cXV0xY8YMHDp0SL9PY2H7qqoqHDt2TN8XobDt+UofHx84Ozvj3LlzePrppzutcLi1tTVcXV2NklddNe6NY1NfX4+KiooWx6Yt49yefU3F53Wh0+lw+vRpuLu7Y8KECXjxxRdx7do1CAQCfR203uDKlSuYOnUqXnnlFbz00ks4d+4cJa4IaUV5eTnOnj2LL774AomJiXjuueegUCjg4OAAHx8fPP3000hOTgbHcRgzZgzWrl2LjIwM3Lx5E2VlZThz5gy++OILJCQkIDIyEgqFghJXhBBCCCG9GWvBlStXmIuLC/P09GTp6elMo9Gw8+fPs2nTpjFvb28mEomM3jNr1iwGgE2ZMoUdOnSIVVVVsZMnTzJra2v2+++/G+xTXV3d7HtnzZrFjh8/ziorK1lGRgazt7dn/v7+Rm2NHDmSeXp66p/X19ez+Ph4FhISwsrKylrqloFt27YxAGzjxo3Nvt5crAsWLGASiYSlp6eze/fusdLSUrZ06VIGgB06dKhN7bbUzoN9P3jwIHN2djbqe0lJCZNKpax///4sLS2NqdVqlp+fzyIiIphAIGCbN2822F8sFrOAgACTY/r3v//NHBwc2IYNG/TxhYaGsrq6Ov0+M2fOZAD0X88880ybj+/r68s++OCDZl/rqnEXCoXMxcWl2ddMGWdTz0lbWcJ1YWVlZXCOra2tmUgkMthua2vLfH19WW5ubrv6aclqa2tZUlISE4lEbNSoUezMmTN8h9RtvfzyyywkJITvMEgnu3HjBsvIyGAbNmxgKpWKKZVKNmDAAP3/DyKRiMnlchYZGckSEhLY1q1b2ZkzZ1hVVRXfoRNCCCGEkO7jQIvJq8jISAaA7dy502D7jRs3mEgkajV59eOPP7bY4sOSV2lpaQbbn332WQZAn/xq9GDyqry8nE2fPp3Fxsay+vr6Fttuqj3JK6lUyiZNmmS079ChQzucvGra9xdeeMGo7y+99BIDwL7++muDfWtqatjAgQOZvb09Ky0t1W9vT/Lq999/ZxKJhE2fPl1/7KlTpzIAbM6cOayhoUG/L8dxzN7e3qRxZ4yxgIAA3se9teSVKeNs6jlpK0u4LqytrQ2SV819WVlZsTFjxpjcPz7l5OQwnU7X6j7Hjh1jcrmcOTg4sKSkJJOvcWKIklfdV01NDcvJyWE7duxgSUlJLCoqio0ZM4Y5ODjo/x9wdXVlAQEBTKVSsaSkJLZnzx5WWFho8POCEEIIIYSQdjrQ4rTBAwcOAACmT59usH3gwIEYOnRoq3dzjRs3rtXXW+Pv72/w3MvLC8D9Qq7Nyc/Px/jx42FlZYUNGzaYfVrBk08+iePHj0OlUuHkyZP6KWv5+fl4/PHHO3Tspn339PQEYNj3Xbt2AQBmzpxpsK9IJEJwcDCqq6vx008/dSiOzz77DGq1GnPnztUf+4cffsC4cePwzTffYOHChfp9s7KyEBgYaPK4C4VCk6YwmnPcm2PKOJv7nPB9XTzs3Op0OqxcubJdx+bDjRs38MQTT2DLli3Nvl5VVYXExERMnjwZ/fr1Q3Z2NhISEmjKEunxysvLcfToUWzatAmJiYkICwuDj48PHBwcMHz4cMydOxebNm1CeXk5lEol1q9fjyNHjkCtVqOsrAxHjx5FamoqEhISEBYWBplMBiurVqsTEEIIIYQQ0ibNZg+0Wi00Gg3s7OyaLdLdr18/XL58ucWDisXidgckkUgMntva2gIwLhoN3P9FOzw8HIMGDcL+/fuxfft2zJs3r91tt0VKSgomTpyIrVu3Ijg4GAAQFBSEmJgYzJ49u0PHbtr3xl/6G/uu1WqhVqthZ2cHJycno/f3798fANpd66tR47ltPB4AODo6Yv/+/ZgyZQo2b94MJycnrF69GsnJyXjrrbc61F5bmHPcmzJlnLvinPB9XTg4OECj0TT7mrW1NUaPHo2QkJB2Hbur1dbWYvbs2bhz5w7i4+MRGhoKDw8P/ev79u3D4sWLodFo8OmnnyI6OhoCgYDHiAnpXHV1dbh27ZpRwfQLFy7g7t27AAAXFxf4+PhAJpMhKioKCoUCMpkMCoUCdnZ2PPeAEEIIIYT0Rs0mr0QiEZycnKDRaFBZWWmUwCorK+uS4B5GKBQiMzMTEokEkyZNQnR0NHx9fY3uVOlMAoEAUVFRiIqKQl1dHbKysrBmzRpERERg7dq1iI+PN1vbIpEIEokEarUaGo3GKFFx69YtAMCAAQMM4jVVnz59AACXLl3CtGnT9Nvd3NyQnp6OwMBArFu3DkeOHIFYLEZkZKTJbWRlZZm0vznGvaWxMWWc23NOOpu5rwsnJydotVrU1tYavdbQ0ICkpKR2Rt71YmNj8csvv4AxBq1Wi1deeQXff/89bt26hddffx3btm1DZGQkUlJSaDVM0q1VVFSgsLBQn5xqTFTl5ORAq9UCADw8PKBQKKBQKPRF0WUyGaRSKSVtCSGEEEKIRWnxfv4ZM2YA+O/0wUZ37txBfn6+eaNqIycnJ3h6esLR0RF79uyBo6MjwsPDzboCmouLC/Ly8gAANjY2CAkJ0a+St2/fPrO126jxLqOmbWm1Whw8eBD29vYGUz0dHBwMkg6+vr7YtGlTm9pYv349ysvLDV7z8PBAZmYmXFxccPr0aSiVyi75kGOOcRcKhQZ39D04NqaMs6nnxBzMeV2IxWLU1dUZbRcKhRg/fjymTp3aGV0wuy+//BL/+Mc/9FNO6+rqsGvXLixduhTDhg3DkSNHcODAAezYsYMSV6TbuHnzJjIzM7Fp0ybExsYiJCQEPj4+cHV1xdixYzFv3jxs27YN1dXVUCqV2LRpE86cOQONRoObN28iIyMDqampiI2NhVKphEwmo8QVIYQQQgixOC0WHVqxYgUyMzMRFxcHiUSCiRMnori4GPHx8XB0dIRare7KOB/K29sbO3fuREhICCIiIpCVlQWRSGSWthYuXIiPP/4Yvr6+UKvV2LhxIxhjXfIhfuXKlfj5558RFxcHR0dHTJkyBSUlJXjzzTdRUlKC1NRUg+l+o0ePxokTJ3Dt2jVcv34dHMchKCio1TbGjx+PxMREJCUlITAwEB999BGmTJkCgUCAX3/9FRs2bIBYLIZAIMD7778PmUyGF198sc19OHv2LKbJ/D64AAAgAElEQVRPnw4/Pz8cPny4zTVROnvc+/Tpg9LS0mbHxpRxNvWcmIM5rwtHR0cwxoy219fXd5u7rs6dO4eXX37ZaLtAIMDmzZsxb948rF69ukNTngkxl9raWly5csVgml9ubi7y8vJQVVUFAHB1dYVMJoNcLtcnoeRyOfz8/KheGyGEEEII6f5aK+een5/PwsPDmbOzM7O3t2f+/v5s7969LDg4WL/C0Msvv8xOnDjR7CpkD9q1a5fR63Pnzm32vcuWLWPs/qdlg6+ZM2eyr7/+2mj7+vXrmz3O3LlzWy1X39Jqgy3Fyhhj2dnZLCYmhg0bNow5ODgwNzc3NmHCBLZ58+aHrl7WlKl9b3Tnzh0WFxfHpFIps7Gx0a8MePDgQaM28vLyWFBQEBOLxczLy4ulpKS0Ob69e/eyp556ivXt21e/Ml9AQABbu3Yt02g07Pjx4warTQFgdXV1Dz3u6dOn9eP24EpUXTXujZ599lnm6ura4tiYMs6m7PswlnRdWFtbs/Hjx7M+ffoYtCsUCtnkyZNN7hsfysrKmJeXFxMKhc3+P2VjY8MWLlzId5g9Hq02+HBlZWXszJkzbOvWrSwhIYFFRkYyuVzOrKys9N93MpmMKZVK9tprr7HU1FSWkZHBSkpK+A6dEEIIIYQQczogYKyZWyp6ie3btyMqKgobN240WEGP9A4LFixAcXEx0tPT+Q7FYgmFQowdOxZubm746aefDKZZ/vzzz5g8eTKP0T2cTqfDjBkzcOjQoWanPjYSCAT4+eefH3pXImk/+n67r76+HsXFxUa1qC5cuKCvTycSieDj4wOFQgG5XK6vRSWXy2Fvb89zDwghhBBCCOlyP7U4bZAQQhpNmDABBw8eRG1tLYRCIYKCgiw+cQUA77zzDjIzM5tdrfRBVlZW+NOf/oSLFy+abbox6V20Wi0KCgqQm5trkKTKzc1FdXU1gPtT/RqTU0qlUv+YCqYTQgghhBBiiJJXABYtWoRFixZBLBajsrKS73AI4VViYiJWrVplsM3f319f4L2+vh7vvvsuH6GZJC0tDR988EGz9boeJBAIYGVlhcLCQqxYsaJb9I1YjvLycoPkVOPjoqIiMMZgY2MDLy8vfS0qlUoFuVyOkSNHGq0MSgghhBBCCGler542aC5t+Yv58uXL8c4775g/mF7E1HHv6mlM3fm6+P3339GvXz8IBAJMnToVmZmZfIfUqoKCAjz22GOoqqoySl5ZWVnBysoK9fX1EIlEGDVqFB5//HEEBARg8uTJkEgkPEXds3XnaYN1dXW4du2aUZLq/Pnz0Gg0AAwLpj84zY8KphNCCCGEENJhNG3QHCgfyA9LH3dLj6817u7uGDhwIG7evIkPP/yQ73BaVVVVhaefflqfuGpMHDQ0NMDFxQVTpkzRJ6see+wxCIX03yC5r7y83KgW1cWLF5Gfn4+GhgYAgIeHBxQKBRQKBSIjI/WJKplMxnP0hBBCCCGE9Fz0qY0Qc6itBQ4fBg4eBM6dA0pKgLt3+Y6qQyaq1ai0t8f4F17gO5RWqcrKcKmiAgAw2N0dj0+bhilTpyIgIAC+vr48R0cswc2bN42m+XEcB47jAAC2trYYMmQIFAoFwsLCkJCQAIVCAT8/P4jFYp6jJ4QQQgghpPeh5BUhnemPP4CPPgL+7/+AO3cAuRwYPRp47DHA2Znv6Dpk/OHDmCKVAl5efIfSooMFBeh77hx2ODoi8PZteFy6BKSlARIJMG0a3+GRLlRbW4srV64YJany8vJQVVUFwHCq34MF0729vWFlZcVzDwghhBBCCCGNKHlFSGdoaABSU4G//hWwtQVeew2YPx/4n//hO7JOEx0TAxcXF77DaFXw//+lV1oKfPUV8MknwNatwJtvAv/7v4CdHU8Rks7WUsH0q1evQqfTQSgUYvDgwZDJZAgICIBKpYJMJsOIESPQr18/vsMnhBBCCCGEtAElrwjpqOvXgdmzgfPngbg44O23gR64ipilJ66aNWAAEB8PvPIKsH498OGH95NYu3ffvyuOdAv19fUoLi42muZ3/vx53L59GwAgkUgwZMgQyP4/9u47PKoyYf/4PemVJNRQhdANiKiAKCCLQSlRIqJUsVH2ByxEBELVV2miSFHBhgiCCspKWZUOFlCWsiJKCUU6CRAhkED6zO+PYyIhCSQhmTPJfD/XNddMznnOmXsmi++V+33Oc0JC9NRTT2WtRRUaGiovykoAAACgRKO8Am7Fzp1Sly5SUJBRXrGmkmPy9JRGjzZmw3XvLt13n/TFF1xK6GAuXbqkw4cP57poenJysiTjUr/My/vCw8OzSqpatWrl646eAAAAAEoeyiugsL7/XurUSWrdWlq61FhXKT+OHzdKrz/+kOLjjUsOUXAWixQYKNWsaawpVq/ezY+pUkXasEHq31/q3Fn69FPpySeLPSqyu/ZSv2tLqqNHj8pms8nd3V3Vq1fPWotqwIABuv3223XnnXfKz8/P7PgAAAAA7IzyCiiMQ4ekxx83yqvPP5fcbvJP6exZad48adEnUvRBycVF1rKBsvp6Sy7MFikUm00uV5LlcjFeSs+Q7bYasvTqLQ0ceOO1xjw9jUsHg4Kkp5+WatSQ7r3XfrmdRGpqqk6dOpVVTm3dulWxsbHy9/dXYmKipJwLpme+btCggVxdXU3+BAAAAAAchcVms9nMDgGYoV+/fjpx4oTWrVtXsAPj442yIyBA+u47yds777EpKdKMGdLkSbJZLEpqdrtS76irtFpVZfNwv6X8MFjSM+R2Ikaevx2W1/a9ckm8aqw9NmHCjdcey8iQIiKkHTuk7duNEgsFdvHixVwv84uOjlbGX7MKK1euLIvFIjc3N40bNy5rLarKlSubnB4AAABACbCW8gpOq9Dl1eDB0vLl0v/+ZywInpfvvpOee1a2mBhdfailrj7YXDZ3JjsWK6tV3lt+kd83W2Tx8ZXmvit17Zr3+IQEo4isXVtatcp+OUugM2fO5LjMb+/evYqJiZEkeXp6qnbt2llrUGWuS9WwYUP5+PgU/t8bAAAAAGe3lr+kgYL4/Xfpgw+k+fNvXFx9+KE0aJBSGtdRQv8BsgaWvrsPOiQXFyW1uVspd98u35XfybtbN+mVV4w7QOa2mLe/v/T++1KbNtK33xqXgTqxlJQUHT58OFs5tW/fPu3fv19Xr16VlH3B9LCwsKzXNWvWlIuLi8mfAAAAAEBpRHkFFMTQodI990h9+uQ9ZtQoafp0XenUSlc6tZZY0srurL7eSujVUenVg+X/yitSdLSxzlVu6yi1amWsXzZ8uPTww7mPKWWuXTD92pLq2LFjslqtWQumh4SE6P77789aMP2OO+5QmTJlzI4PAAAAwMlQXgH59csv0ubN0qZNuc/ikaQ33pDefFOXn35Eyc0b2Tcfckhq3VQZ5QMV8P6XspQtK731Vu4Dp0yR6tc3Zl898oh9QxaTtLQ0nTx5MkdJ9dtvv+ny5cuSpMDAQNWuXVshISF66qmnsi75Cw0NlZeXl8mfAAAAAAAMlFdAfi1aZBQcbdvmvv/bb6XRo5X4+IMUVw4ktWEtXX46XAFz3jF+f4MH5xxUt67Urp3xOy5geWW1Wk29XC4+Pl5HjhzJddH05ORkScaC6aGhoQoNDdUTTzyRVVLVqlVLlryKWAAAAABwEJRXQH6tXm3cnS63P/ZPn5aefEJJrZrq6j+a2T8bbiilaQNdCX9AvsOGSfffL915Z85BERHSuHFSerrkdvP/NKalpemjjz7SwoUL9fPPPxdD6uwyF0y/vqQ6evSobDabPDw8VK1aNd1+++0KCwvT0KFDFRoaqvr168vPz6/Y8wEAAABAcaG8AvLj8mVj3aT77899/8iRyvD1VuLjD9o3F/LtysP3yePAUbkPGiRt3ZqzhLz/fuP3fOiQ1LBhnuex2Wz68ssvFRUVpWPHjslisejq1avy8fG55Yypqak6depUVjmV+RwdHa3ExERJxoLpmXfzCwsLy3rdoEEDuTrBel0AAAAAnA/lFZAfhw9LNpvUoEHOfT/9JC1ZosSB3WRz55+Uw7JICY8/qLLTPpaWLpV69Mi+P7OwOnw4z/Jq69atGj58uHbs2JF1uZ3NZlN0dLSaNm2a7ygXL17M9TK/6OhoZWRkyM3NTTVq1Mi2YHpISIgaNWqk4Bvd5RIAAAAASiH+0gbyIz7eeA4Kyrnvlf9TWv2aSrmjrn0zocDSqwcruXljeb76iizXl1deXpK3t3TxYo7jfv/9d7300ktavny53NzcZLPZZLPZJEkuLi46cOBAjvIqPT1dJ06cyFFS/f7774qNjZUkeXp6qnbt2goNDdUjjzyiqKgohYaG6vbbb5e3t3fxfAkAAAAAUMJQXgH5kZZmPLu7Z99+/Li0YaOuDnjc/plQKFf/cY+8ps43Zszdd1/2ne7uUmpq1o/Hjx/XpEmT9NFHH8ntr3Ww0tPTrzvEXT/++KPS09O1f/9+RUdH68CBAzp8+LBS/zpX9erVVb9+fTVo0ECPPfZY1uuqVasW74cFAAAAgFKA8gq4FatWyeblqdTbQ8xOgnxKrx6sjOAKcl21Kmd59Ze4uDi98cYbmjlzpiTj0sC0zALzOmlpaVq1apXmzZun6tWr6/bbb9cjjzyStRZVkyZN5O/vX2yfBwAAAABKO8or4FZs2aK0OtVlc2Oh7JIktV51ef/wfY7tl202TV+5UtOHDlV6enqehdW1rFarfHx8lJSUVGwLpl+5YkwIS001XktSQoJxY0SrVbp0ydiWnCwlJRmvL10y9l0rt23XnjO/fH0lD4/s23x8JE/Pv38OCJBcXIzXLi7SmTO368KFstq1y7iZo7+/Md7Hx7ha08urYBkAAAAAOA/KK+AW2H7bo7TbypsdAwWUXrWi9M1PWT9brVa9/fbbmpSYqLivvy7w+Y4fPy6LxaLERGU9Ll0yHomJRtGUmGgsnZb5OinJeJ2WZmxPSZGuXjX2paUZS28VpljK5O9vlETXyq10cnExiqb8yizSrpdZpknGvQ0yl4n723BJ0j335H1uPz/jys2AAKlMGePh7288BwRIgYHZt5UrJ5UvbzwqVTK2AQAAACh9KK+AW2A5f17WxjVu6Rwrdu7TwPkrJEkebq46+VbULZ1v9a8H9cz7y7J+PjF7lDy5C2I2Vn9f6fJlo4Xx8JCLi4uee+453T1ugrZ17KZdbh769ddd+uOPvUpJSZLFYpGrq6cyMlJls1lznC81NVVubsdks+V++aiHh1G4ZJYyfn7GTKMyZYyyJiTEGOPr+3fBFBho7PP3/3tmUuaMJSn7TKfM+whknsPRpKZKzz8/VKdOxeijj75UWppR0mUWdklJxqyxzGLs0iXj15OQYDxfviz98cff5V/mtuuLPQ+Pv8usChWkihWNUuu226Tq1aVq1YznypWlv24WaTdLlixRz549JRkL9ScnJ9s3gKTp06dr5MiRkqSqVavq1KlTds8AAAAAFAZ/0QK3IjlFusViKOKe2xVxz+3qNvsz/ffIyWz7rqSk6sEpH6lOpXJaPOjJfJ2vY5N6Ojt3rJ5+b5nW7Dl4S9kKqzC57cnm8dfC+0lJWVOR/P395asmGrls/jUjrXJ1/UO+vrvl7r5HVusvSkr6RcnJpyVJrq7GeTIy0jR6dLRatw6Rn1/22UL+/jlnOzkbDw/J0/Oq3N0vKaQIl4dLTpbi4qTz56WzZ43XmY9z54ztP/8sLV0qxcYaM8Iy81SpYhRZdetK9etLDRsaj1q1pOK4+rNHjx7q0aOHwsLCtGXLlgIfn5iYqKZNm6p+/fr6uhCzAyVpxIgRGjFihO68807FxcUV6hwAAACAGSivAAdms0lWm03WzL+6r1Er8g01ql5J/3mxrwnJbuxGuR1ZfZdD2vTiNwrq01lBQVLZsi7y968jqY6kblnj4uPjtWfPHv3666/as2ePdu3apRo1jqtjR9OiOyUvL2M2VbVqNx+bmiqdOSOdPCmdOCGdOmW8PnhQWr/eeC0Zs9nq1ZMaNJCaN5datjQudbx2PS8z2Gw2Wa1WWa9ftAwAAABwApRXgAPz8/LQ9lcHmR2jwEpqbh9Lkv7RIEa688bjAgMD1aZNG7Vp08Y+wXDLPDykmjWNR24SEqQDB6T9+43Hvn3S9OnGjC5PT+nuu42bUz7wgPTgg8alnPbk7++vI0eO2PdNAQAAAAdBeQUAcHr+/lKzZsbjWkeOSD/9ZDzWrpVmzDBmfD38sPTcc1LHjsVzmSEAAACAv1FeAXZ2KPZPTVqxWVsPHle61ao7qgdrXETbHOPyWnh97ob/6pWvNkqSth85pUqDpkiSXF0sOvPOmBznOXf5iiau2KTN+/6Qi4uLmtWqqklPtFfNCkHZxv2ZeFUzvt2iNXsO6eylBPl7e+neOtX1YqdWalStUq6Ztr48UNP+84N+iD6m+CtJkqQZvTtp+Kff5sh9/bE7Jw7OV65rv6+0jAw1qFJBIzq11vubtuvH6GOSpF73NdHMPp1v+t0DBVW7tvF46inj59hYadUq6YsvpEcfNRaDf+klqW/f7CXWgQMHNHr0aG3evFnp6em66667NHXq1BznX7FihR577LFsx02YMEEbN27UhQsXJEkffvih+vfvnzUmKSlJXl5eOY49evSooqKitHbtWrm6uqply5aaPXu2ateufcPPuHjxYj2V+QH/EhMTo+Dg4Hx/TwAAAEBxcjE7AOBMjp6/qM5vLNSvJ2L0Uf+u2jttmKb1fFgzvt2iY3EXs43NXHi9wx31sm0fFNZCZ+eOlY+Hu5rXrqazc8fq7NyxuRZXkjT+y/Ua8I/m+nXqUH3U7zFtO3wy6+6Gmc5eStRDr32slf/br2k9Oih6+nCteKG34q8kqdMbC7Xzj9O5Zhr52Wo92+Yu7Z48RKtHPSNXF0ueua/ffm2uD5+P0I/Rx3Lkuv772vd6pN7qG64PNu/QvtPn5OHmqrNzx1JcwW6Cg6UBA6QNG4z1sh5+WBo4UGrf3lggXpIOHz6sli1baufOnVq2bJnOnj2ruXPnauLEiTku/YuIiJDNZlOXLl0kSQMHDtSgQYN08uRJbdu2Ta6urjnG5HVsZGSkIiMjdfr0aS1dulSbNm3KusPhjfTs2VPDhw9X+/btdeHCBdlsNoorAAAAOBTKK8COpqz8TpeSkjXpifZ6oGEt+Xp6qGGViprd9xGdvZRYLO/Z5/47dU9IVfl4uKtV/Zpq37iOdh+P0YXEq1ljJq/crFMXLunVx8MU1qi2fD09VL9yBb3//GOy2Wwa+8XaXM895KGWuq/ebfL2cNddNavozDtjVNbPp8C52jSopfaNcubK7fuqX7mC3nuui66mpt3aFwPcojp1pPfek3bskI4fl7p2ldLTpbFjxyo+Pl6zZ89W+/bt5efnp8aNG+vjjz9WTEzMDc8ZFRWltm3bysfHRy1atFB6errKly+frzz9+vVTy5Yt5evrq7CwMHXu3Fk7duy44Z0F4+Pj1blzZ2VkZGj16tUKCgrKcywAAABgFsorwI427TNmXfzj9pBs24MD/FS7Yrliec87b6uc7efKgf6SpNhryrLVvx6Ui8Wi9o3rZBtbsYyvGlSuoF9PxOpMfEKOc99Vs0qR5aoSVCZHrry+r3J+PqpbqXi+L6CgmjQxLiXcskXatk1as2aNJOnhhx/ONq5KlSqqV69ebqfI0rx580LnaHbdgl3Vq1eXJJ05cybX8dHR0WrRooVcXFw0a9YsubJ4FwAAABwUa14BdpKanqHE5FR5urvJ19Mjx/7y/j46cu7PIn/fMt6e2X52sVgkSVabLSvX5aQUSVKd4W/meZ6j5y6oyl/FVyYfD/ciy+Xh5poj142+rwAfr0K/N1DUqlQx1rw6dy5FCQkJ8vLykp+fX45xFStW1MGDB/M8j6+vb6EzBAQEZPvZw8P4d2O1WnOMvXjxoiIiIlStWjWtXr1aixcvVp8+fQr93gAAAEBxorwC7MTDzVV+Xh5KTE7VlZTUHIVM/NWkAp3P8lcJVRS5Ary9dCUlVcffGiU3F8eYkHmz7ysu4WoeRwL2lZhoLOgeHCyFhXnK399fCQkJSkxMzFFgZS7CbjY3Nzdt2LBBAQEBuu+++9S/f3/Vr18/x+wtAAAAwBE4xl+pgJN4MNS469emfX9k234h8aoOny3YH7XeHu5KTc/I+vm+/3tPi7b8UqhcnZvWV7rVqu1HTuXY9/a6n9V03DtKz2X2RnHL6/s6d/lKscxSAwrCapW+/NK4bHDHDunf/5bKlJE6duwo6e/LBzPFxcUpOjrajKg5+Pv7q2rVqvLz89OqVavk5+eniIiIm67JBQAAAJiB8gqwo7GPtlWgr7cmfLle3+8/qispqToYE6dBC1blemncjdxRvZL+OHdBZy5e1s4/Tut4XLzurVO9ULnGdWmrmhWCFLnoa23ce0SXk1IUfyVJn/z4i978dov+r+uDpszIyu37OnDmvIZ98h9VLJPzkix7unJF+vZbadgwqX596dgxU+PAjg4dkiZNMhZs79FDuv9+6ZdfpBYtjP1TpkxR2bJlFRkZqfXr1ysxMVH79u1Tnz59cr2U0Gw1a9bUsmXLdP78eXXt2lUpKSlmRwIAAACysdhsfy0wAziZfv366cSJE1q3bt3NB69dK3XoIMXHS9euK+Pvr4QubZR0/535ft8j5y5o4vJN2hJ9XGkZGWpQpYJGdG6t9zdu14/RxyRJve5rooca19Uz7y/LduzjzRtp7jOPSpIOn/1TL376rfaciFWgr7eGPtxSz7a5W7uOnlanNxZmOy6yw/0a8+gDqjRoSrbt7RvV0eJBT0qS4q8kaeaan7T612iduXhZZby91Lh6JQ1uf6/aNKglSbmeW5LOzh2b9Xr1rwdzzf38A3cXKte131e61apG1SppXERbvf71j/rl2BkdmzUy7y87Dx77/lDgO0ty/j4DAqQ335T69ctxjM0m7dlj/E9h9Wpp61YpLc1Y5ygjI+epkF2B/r05mLNnpe++k77/3njev1+qVEnq2VMaNEiqWzfnMQcPHlRUVJQ2bdqktLQ0NWrUSC+//LJmzpypjRs3SpKef/75rDsEXu/a/9O8YsUKPfbYY9n29+7dW0OGDMlx7Lhx4zRp0qQclxV37txZffr0Uc+ePbNtnzlzpu69994c5+ndu7cWL158s68GAAAAsIe1lFdwWmaVVyga97/yvpLS0vS/SUMKfGx+y6u4OGnzZmn9emnlSuncOcnd3Sirrr2K0tXVKLKKaBmyUqmklFenT0u//24Ulb/9Ju3aJe3bJ7m5SffcI7VtK7VvLz3wgPF7BwAAAFDs1rJgOwCHde7yFbV+9X39Pi1S7q5/X7Z48s9LOnb+oro1b1Sk75chV+0+Xl4bpklffWWsYyQZJUV6uvE6LS3ncX5+FFclSUyMdPSocann0aPG4/Bho6zKXE+9alWpUSPp0Uel6dOl1q2N3zMAAAAA+6O8AuDQ4q8ma+Rn32pUeBsF+XrrwJnzGvPFOvl5e2p4p1ZF8h7p6dLUqdIbCSeUMClnQ5FZXOXFz0+6eFHy9zdm6MAccXHGJX5nz0pnzhgz5c6cMX6OjTVmVR09KiUnG+Pd3aUaNaSaNY11y7p1MwqrO+6QypY19aMAAAAAuAZ/ZgG3wsNdyrD/XficRcUyvlo2rJfmf79Lj85YpNhLiQr08VKbBrX03rNddFv5wEKd15Lx110aPYxF8t3cpAkTpLBpj2n27e/r37+EyMVFSk3N3/kSEv4uO7y8jDKrTBnjKkQ/v78fQUHGs6/v3w8PDykw0Hj285N8fCRPT+NYd3fjPB4extjSKjlZSkoyCsCkJOnqVenSJWNR/KQk6fJlKTHR2H/hQt7P114E7+EhVaggValirE91223Gwuo1a0q1ahnP1apx6R8AAABQElBeAbfAFhgol6tJZsco1VrXr6nW9WsW6TktV5KNlsnbO9v2lq7b1XLAJp19JEQLFkgzZxqzd1xcjHWu8hIaKr36qlGwZD4uXfq7dElIMJ7/+MN4vnr17+eUFGPprfyuPhgQYOS5ttDK3ObpaZRfmYKCsh97/X7JKMcKUuCkpBi5r5VZPl0rKcnYnp5ufP7jxyfoyhV31a799+dOSzO+hxtxdTUy+vsbJV/ZssbnqlZNatzYeJ25rXx5KThYqljRKK4AAAAAlA6UV8AtsDRoKNeYE2bHQAG5xcbJVqeO8lqmqlIlKSpKeuEFY6H2d96RfvjBmAl1/ZpXFosxqycs7NYyZRY51xZaqanGtmvLoYsXjefMciivbRkZRnl2rYsXjcvnrt9WEG5uRpF0s22BgUZR5uJilGurV+/T1atn1a/fM1m9YWYxlVmqZR7j7W28zpyZBgAAAMC5UV4Bt6JFC3m89bNkk/JsQuBwPP44LUvbh24+zkN64gnj8b//Se+9Jy1caNxpMHMdLDe3nDOcCsPd3ThPUZzLEcXF/VsnTpxQVNQzZkcBAAAAUMK43HwIgDx16iSXPy/K/USM2UmQTy7xCXI7clLq3LlAx911l/TBB9LJk9LLLxuXplksxgynwMItvQUAAAAAyAfKKyA/MhcFsl63OPs998jWsIG8f/zF/plQKN5bfjEWSerYMedOq/WmC0BVrCiNHy+dOiV9/rnUokXpnS0FAAAAAI6A8grIjzJljOeEhBy7LKOi5PXf3+QWc97OoVBQLpevyOe7XdKwYcZCS9fKyDBub5f5u74Jd3epe3fpp5+koUOLISwAAAAAQBLlFZA/1asbz0eO5NzXt6/UtKn8l220byYUmN/KzbIEBUkvvphz59Gjxi3/atQo8Hmv78EAAAAAAEWH8grIj8qVjVvQbd+ec5+Li/T223I/cFReP++xfzbki8f+o/La9ps0a7ZxS7vrbd9uTKcKDbV/OAAAAABAniivgPx66CHpm29y33fvve5H1ogAACAASURBVNLo0SqzZK3cD5+0by7clFtsnALmr5R69ZK6dct90DffSK1a5V5sAQAAAABMQ3kF5NeTT0pbtkiHDuW+f9IkKTxcgfOWyzX2T/tmQ55cLiUq4L1/y3LHHdJHH+U+6OJFafly43cMAAAAAHAolFdAfnXsKNWqJU2enPt+Fxdp8WJZbm+ksjMWy+PgcfvmQw5up86q7PRP5BpYVlq5Ku/Fqd5809jXu7d9AwIAAAAAboryCsgvV1fp9delTz4xZmDlxsdH2rRJlk6dFfjOEnl/v8tYBBx257lrv4JmLJbLHU2lbf+VKlTIfeAffxjl1f/9n+Tvb9eMAAAAAICbo7wCCuLxx6V//EMaPlxKS8t9jLe3tGSJNH6C/JdtUNnpi+R+9LR9czoxt5g4Bb6zRAHzV8jy3HPS2rVSUFDug2026YUXpJAQadAg+wYFAAAAAOQL5RVQUO+8I+3fLw0ZkvcYi0V6+WVp92653VZHQdM/UeB7y+T52yFZ0tLtl9VZZFjlEX1MAR+vUtkpH8nDs4wxO27OXOMOgnmZPFn69ltp7k3GAQAAAABM42Z2AKDEadhQ+uIL6ZFHpPr1jVlYeWnUSNq8WVq5Uh4zZ8rjvWWyebgrvUYVZVQIkNXHy1grCwVns8lyNVluf16S24lYWa4mSffcLX38sbF21c2+12XLpJdeMsrIBx6wT2YAAAAAQIFRXgGF0bGjNG2aNHKklJoqjR594/FduhiP06dlWbtW7jt3yv3wYdkuXJAymIlVKBYXWYLKSq2bSXfeKXXoYFz+lx8LF0oDBkhDh3K5IAAAAAA4OMoroLBefNFY4HvwYOngQem99yQPjxsfU7Wq9NxzxkOSxQ4xcQ2bTXrlFeMxdKg0Y4bZiQAAAAAAN8H1SsCtGDBA+uYb6auvpMaNjfWT4Jh27ZJatZKmTpUWLJBmz+aSTQAAAAAoAfjLDbhVDz0k/fKLFBoqde5sXB74009mp0KmPXukp5+Wmjc3Zsbt3Gn8DAAAAAAoEbhsECgKtWoZs682bDDWv7r/fqlOHWNtrLvukmrUkAICzE7pHC5fls6cMQrFdeuk334zFtZfskR64gmz0wEAAAAACojyCihKYWHGzJ4dO6R//1vauFGaN09KSjI7md2kSFos6SlJN1kBrPi4uxt3hWzXTnr7balNG8nCCmMAAAAAUBJRXgHFoVkz4yFJGRlSfLx06ZK5mezkfGysBrVtK9srr6hf9+72D+DvLwUGGgUWAAAAAKDEo7wCipurq1SunPFwAtVCQtT36ac1dd48PTNypNzc+M8MAAAAAKDwWLAdQJEbM2aMTpw4oS+++MLsKAAAAACAEo7yCkCRCwkJ0ZNPPqlJkybJarWaHQcAAAAAUIJRXgEoFuPHj1d0dLRWrVpldhQAAAAAQAlGeQWgWDRs2FCPPvqoXn31VdlsNrPjAAAAAABKKMorAMXmpZde0u7du7V+/XqzowAAAAAASijKKwDFpmnTpmrfvr0mT55sdhQAAAAAQAlFeQWgWI0bN04//PCDfvzxR7OjAAAAAABKIMorAMWqTZs2at26taZMmWJ2FAAAAABACUR5BaDYjR07VmvWrNHOnTvNjgIAAAAAKGEorwAUuw4dOuiee+7R1KlTzY4CAAAAAChhKK8A2MWYMWO0fPly/f7772ZHAQAAAACUIJRXAOziscceU2hoqKZNm2Z2FAAAAABACUJ5BcAuLBaLoqKi9Pnnn+vQoUNmxwEAAAAAlBCUVwDspmfPngoJCdH06dPNjgIAAAAAKCEorwDYjaurq0aMGKGPP/5YJ06cMDsOAAAAAKAEoLwCYFfPPvusKleurJkzZ5odBQAAAABQAlBeAbArd3d3vfDCC/rggw907tw5s+MAAAAAABwc5RUAuxswYID8/Pw0e/Zss6MAAAAAABwc5RUAu/Px8dGwYcP0zjvvKD4+3uw4AAAAAAAHRnkFwBRDhgyRi4uL5syZY3YUAAAAAIADo7wCYIoyZcpo8ODBmjlzphITE82OAwAAAABwUJRXAEzzwgsvKCUlRR9++KHZUQAAAAAADoryCoBpypUrp/79++v1119XcnKy2XEAAAAAAA6I8gqAqUaNGqX4+HgtWLDA7CgAAAAAAAdEeQXAVMHBwXr66ac1depUpaWlmR0HAAAAAOBgKK8AmG7s2LGKiYnR559/bnYUAAAAAICDobwCYLoaNWqoR48emjp1qqxWq9lxAAAAAAAOhPIKgEMYO3asDh48qK+++srsKAAAAAAAB0J5BcAhNGjQQF27dtWkSZNks9nMjgMAAAAAcBCUVwAcxvjx47Vnzx6tXr3a7CgAAAAAAAdBeQXAYTRp0kQdO3bUxIkTzY4CAAAAAHAQlFcAHMqECRO0bds2fffdd2ZHAQAAAAA4AMorAA7l3nvvVdu2bTV58mSzowAAAAAAHADlFQCHM27cOG3YsEE//fST2VEAAAAAACajvALgcMLCwnTfffdp2rRpZkcBAAAAAJiM8gqAQ4qKitJ//vMf7dmzx+woAAAAAAATUV4BcEiPPPKIGjdurKlTp5odBQAAAABgIsorAA7JYrFozJgx+vLLL3Xw4EGz4wAAAAAATEJ5BcBhPfHEE6pduzZrXwEAAACAE6O8AuCwXF1dFRUVpUWLFun48eNmxwEAAAAAmIDyCoBDe+qpp1SlShVNnz7d7CgAAAAAABNQXgFwaO7u7hoxYoTmzZunmJgYs+MAAAAAAOyM8gqAw+vXr5+CgoI0a9Yss6MAAAAAAOyM8gqAw/Py8lJkZKTmzJmjuLg4s+MAAAAAAOyI8gpAiTB48GB5e3trzpw5ZkcBAAAAANgR5RWAEsHX11eDBw/WW2+9pYSEBLPjAAAAAADshPIKQIkxdOhQpaWl6b333jM7CgAAAADATiivAJQYZcuW1T//+U+9+eabSkpKMjsOAAAAAMAOKK8AlCgvvviiLl++rPnz55sdJZvp06fLYrHIYrGoWrVqN90OAAAAAMgfyisAJUqlSpX03HPPadq0aUpNTTU7TpYRI0bIZrOpSZMm+doOAAAAAMgfyisAJU5UVJTOnj2rTz/91OwoAAAAAIBiRnkFoMSpXr26evfurcmTJysjI8PsOAAAAACAYkR5BaBEGjdunI4dO6Yvv/zS7CgAAAAAgGJEeQWgRKpdu7a6deumiRMnymq15jomIiIia7F0i8WiVq1aZe3buHGjLBaL/vOf/2Rti4yMzDY+PT1d6enpWrp0qdq3b6/g4GB5e3urcePGmj17dp7vmx+LFy/O9l4Wi0WxsbGFPh8AAAAAlFaUVwBKrAkTJujAgQP6+uuvc92/YsUKzZkzR5L06aefasuWLVn7Fi9enLU906xZs7R8+XI9+OCDstlscnNz05o1a9SjRw+1a9dO+/fv18mTJzVgwAANHz5cUVFRhc7es2dPDR8+XO3bt9eFCxdks9kUHBxc6PMBAAAAQGlFeQWgxAoNDVXnzp01efLkPMf06NFDHh4eWrRoUda2pKQkrVy5UnXq1NGqVauUkJCQte+TTz5R3759s52jbdu2GjNmjIKCglS+fHn961//Uq9evTR79mxdvny5wLnj4+PVuXNnZWRkaPXq1QoKCirwOQAAAADAWVBeASjRxo8fr+3bt2vDhg257i9btqw6deqk9evXZ12Wt3LlSrVo0UKDBw9WUlKSvvrqK0nShQsX9N1336lr165Zx4eHh2vz5s05ztukSROlpaVp7969BcobHR2tFi1ayMXFRbNmzZKrq2uBjgcAAAAAZ0N5BaBEa968ucLCwm44+6pv377KyMjQZ599JklatGiR+vbtq549e8rV1TXr0sHPP/9c4eHh8vPzyzr20qVLeumll9S4cWMFBQVlrU81cuRISdLVq1fznfXixYuKiIhQtWrVtHr16qxLFwEAAAAAeaO8AlDijRs3Tt999122Na2u1blzZ5UtW1aLFi3S+fPntW3bNkVERKhSpUp66KGHtGnTJsXExGjhwoU5Lhl85JFHNHHiRPXv318HDx6U1WqVzWbTzJkzJUk2my3fOd3c3LRhwwatXLlSjRs3Vv/+/bVjx47Cf3AAAAAAcAKUVwBKvLZt26pVq1aaOnVqrvs9PDzUvXt37d69W+PGjVOXLl3k7e0tSXrqqaeUkZGhl19+WTExMWrXrl3WcRkZGdq6dauCg4M1dOhQVahQQRaLRZKxblZB+fv7q2rVqvLz89OqVavk5+eniIgIxcTEFOJTAwAAAIBzoLwCUCqMGTNG3377rXbt2pXr/qeeekqS9OGHH2abXRURESF/f399+OGH6t27t1xc/v7Poqurq9q2bavY2Fi98cYbiouLU1JSkjZv3qz33nvvlvLWrFlTy5Yt0/nz59W1a1elpKTc0vkAAAAAoLSivAJQKnTq1El33323XnvttVz3t2zZUnXr1lWNGjX0wAMPZG339vbW448/Lkk5LhmUpKVLl2rgwIF6++23VaVKFdWqVUuffPKJevXqJUlq37697rnnHk2fPl0Wi0W//vqrTp8+LYvFovHjx2vJkiU5ts+aNUvbtm1T27ZtlZaWpm3btsnLy0t9+vQphm8GAAAAAEo2i60gC7YApUi/fv104sQJrVu3zuwoKCLLli1T9+7dtWfPHoWGhpodB9fg3xsAAACAQlrLzCsApUbXrl3VsGFDvf7662ZHAQAAAAAUEcorAKWGi4uLRo0apU8//VSHDx82Ow4AAAAAoAhQXgEoVXr37q1atWrpzTffNDsKAAAAAKAIUF4BKFVcXV314osv6uOPP9bp06fNjgMAAAAAuEWUVwBKnWeffVbly5fXjBkzzI4CAAAAALhFlFcASh1PT08NHz5c77//vs6fP292HAAAAADALaC8AlAqDRw4UD4+PnrrrbfMjgIAAAAAuAWUVwBKJV9fXw0dOlRvv/224uPjzY4DAAAAACgkyisApda//vUvWSwWvfvuu2ZHAQAAAAAUEuUVgFIrICBA/+///T+9+eabSkxMNDsOAAAAAKAQKK8AlGovvviiUlJS9NFHH5kdBQAAAABQCJRXAEq1cuXK6fnnn9f06dOVkpJidhwAAAAAQAFRXgEo9UaMGKHz58/rk08+MTsKAAAAAKCAKK8AlHrVqlVT37599dprryk9Pd3sOAAAAACAAqC8AuAURo8erRMnTmjp0qVmRwEAAAAAFADlFQCnEBISou7du2vy5MmyWq1mxwEAAAAA5BPlFQCnMW7cOEVHR2vlypVmRwEAAAAA5BPlFQCn0bBhQ3Xp0kUTJ06UzWYzOw4AAAAAIB8orwA4lQkTJmj37t1au3at2VEAAAAAAPlAeQXAqTRt2lQPPfSQXn31VbOjAAAAAADygfIKgNN5+eWX9fPPP+uHH34wOwoAAAAA4CYorwA4nZYtW6pNmzaaPHmy2VEAAAAAADdBeQXAKY0bN07r1q3Tjh07zI4CAAAAALgByisATumhhx5Ss2bNNGXKFLOjAAAAAABugPIKgNMaO3asVq5cqd9++83sKAAAAACAPFBeAXBaXbp0UaNGjfTaa6+ZHQUAAAAAkAfKKwBOy2KxaPTo0Vq6dKkOHTpkdhwAAAAAQC4orwA4te7duyskJESvv/662VEAAAAAALmgvALg1FxdXTVq1CgtXLhQx48fNzsOAAAAAOA6lFcAnN7TTz+tKlWqaMaMGWZHAQAAAABch/IKgNNzd3fX8OHD9cEHHygmJsbsOAAAAACAa1BeAYCkAQMGKCgoSG+99ZbZUQAAAAAA16C8AgBJXl5eGjp0qObOnauLFy+aHQcAAAAA8BfKKwD4y6BBg+Tq6qp33nnH7CgAAAAAgL9QXgHAX8qUKaMhQ4Zo1qxZSkhIMDsOAAAAAECUVwCQTWRkpNLS0vTBBx+YHQUAAAAAIMorAMimbNmyGjBggKZPn66kpCSz4wAAAACA06O8AoDrjBgxQpcuXdKCBQty7LPZbLJarfYPBQAAAABOivIKAK4THBysZ555Rq+99ppSU1MlSRkZGVqyZInuvPNOHTp0yOSEAAAAAOA8KK8AIBejR49WbGysFi9erI8//lh169ZVr169tGfPHp08edLseAAAAADgNNzMDgAAjqhSpUq67777NHz4cCUkJMhms8lms8nV1VWnTp0yOx4AAAAAOA1mXgHANRITEzV79mxVr15dP/zwgy5fviyr1SqbzSZJcnNzY+YVAAAAANgRM68A4C9Tp07Va6+9pqtXryo9PT3XMVarlZlXAAAAAGBHzLwCgL80btxYSUlJysjIyHNMWlqajh07Zr9QAAAAAODkKK8A4C/h4eFatWqV3Nzc5OKS938eKa8AAAAAwH4orwDgGh06dNCqVavk6uqaZ4F15swZO6cCAAAAAOdFeQUA1+nQoYNWrlyZZ4GVmJiohIQEE5IBAAAAgPOhvAKAXHTs2PGGBRaLtgMAAACAfVBeAUAeblRgUV4BAAAAgH1QXgHADeRWYLm6uurkyZMmJwMAAAAA50B5BQA3cX2B5ebmRnkFAAAAAHZCeQUA+dCxY0d9+eWXcnFxUUpKCpcNAgAAAICduJkdAACK2uXLl7Vjxw7t3btXFy5cUHJycpGd+9FHH9WKFSu0YcMGjR49usjOW9wsFosCAwNVs2ZNNW3aVPXq1TM7EgAAAADkC+UVgFIhLS1NX331lebNm6fvv/9eaWlpqlixoipUqCAvL68ifa+QkBCdOXNGGzZsKNLzFiebzaYLFy7o9OnTSktLU61atdSjRw8NHDhQt912m9nxAAAAACBPlFcASry1a9cqMjJShw4dUnh4uBYsWKB27dopODi42N5z06ZNateuXbGdv7ikpqZq586d+vrrr7Vw4UK9+eabGjZsmCZMmCB/f3+z4wEAAABADqx5BaDEOn/+vLp06aIOHTooNDRUhw4d0ooVK9SrV69iLa4klcjiSpI8PDx03333acqUKTp+/Lhmzpyp+fPnq379+vrqq6/MjgcAAAAAOVBeASiR9u7dqxYtWmjv3r3auHGjli1bplq1apkdq0Rxc3PToEGDdPDgQYWHh6tbt26aOHGibDab2dEAAAAAIAuXDQIocTZu3KiuXbuqSZMm+uqrr1S+fHmzI5VoZcuW1QcffKC7775bQ4YM0cGDB7VgwQK5urqaHQ0AAAAAKK8AlCy//fabHnvsMXXu3FkLFiyQp6en2ZFKjYEDByokJERdunRRUFCQ3nrrLbMjAQAAAACXDQIoOeLi4vTYY4/pzjvvpLgqJu3bt9eiRYs0Z84czZkzx+w4AAAAAEB5BaDk6NOnj1xcXLR8+XKKq2L0+OOPa+LEiYqMjNTu3bvNjgMAAADAyVFeASgRVqxYoXXr1umjjz5SuXLlzI5T6o0ZM0YtW7bUkCFDWMAdAAAAgKkorwA4vJSUFI0aNUq9evVS69atzY7jFCwWi2bNmqWff/5ZS5cuNTsOAAAAACdGeQXA4S1evFgnTpzQa6+9ZnYUp3LXXXepT58+mjRpktlRAAAAADgxyisADm/evHnq1q2bqlWrZnYUpzNs2DDt3btXP/30k9lRAAAAADgpyisADu3cuXPavn27evToYXYUp3TXXXepbt26WrVqldlRAAAAADgpyisADm3Lli2SpLZt25obxImFhYVl/R4AAAAAwN4orwA4tN9//121a9eWn5+f2VGc1h133KG9e/eaHQMAAACAk6K8AuDQzp8/r+DgYLNjOLVKlSopPj5eqampZkcBAAAA4IQorwA4tOTkZHl7e5sdo9glJiaqbt26Cg8PNztKDj4+PpKkpKQkk5MAAAAAcEaUVwDgAGw2m6xWq6xWq9lRAAAAAMChuJkdAAAg+fv768iRI2bHAAAAAACHw8wrAAAAAAAAOCzKKwClyooVK2SxWLIe0dHRevLJJ1WuXLmsbZGRkVmvW7VqlXXsmjVrsraXL18+z3MeO3ZM3bt3V2BgoMqVK6fw8PBss6ZudXxycnKhzpPpwIEDioiIUEBAgHx8fNS8eXN9/fXXCgsLyzpXv379iuPrBwAAAIAiR3kFoFSJiIiQzWZTly5dJEkDBw7UoEGDdPLkSW3btk2urq4aP368bDabfH19sx3boUMH2Ww23X333Tc8Z2RkpCIjI3X69GktXbpUmzZtUs+ePYtsfGHPI0mHDx9Wy5YttXPnTi1btkznzp3Txx9/rNmzZ2vPnj3y9PSUzWbTvHnzbuVrBgAAAAC7obwCUKpFRUWpbdu28vHxUYsWLZSenp5tVlVh9OvXTy1btpSvr6/CwsLUuXNn7dixQ3FxcUUy/lbed+zYsYqPj9fs2bPVvn17+fn5KTQ0VJ999pmuXLlyS58bAAAAAMxAeQWgVGvevHmRn7NZs2bZfq5evbok6cyZM0Uy/lbed82aNZKkhx9+ONvYChUqqEGDBgV6PwAAAABwBJRXAEq16y8NLAoBAQHZfvbw8JAkWa3WIhlf2PdNSUlRQkKCvLy85Ofnl+P4oKCgAr0fAAAAADgCyisATsvFxUWpqak5tsfHx5uQ5tZ5enrK399fycnJSkxMzLH/3LlzJqQCAAAAgFtDeQXAaVWuXFmnT5/Oti02NlYnTpwwKdGt69ixo6S/Lx/MFBsbq4MHD5oRCQAAAABuCeUVAKf10EMP6cyZM3rnnXeUmJioI0eOaNiwYapYsaLZ0QptypQpKlu2rCIjI7V+/XolJibq999/17PPPqvg4GCz4wEAAABAgVFeAShVtm3bJovFopUrV0qSvL29ZbFYch07adIk9evXT1OmTFHFihX1zDPPaOTIkQoODtaff/4pi8Wi0aNH53rO8ePHS5IsFoumTZsmSWratKnCw8MLPH7FihU5xvfp06fA55Gk2rVr6+eff1azZs3UrVs3VapUSQMHDtSYMWNUq1Ytubq6FuG3DQAAAADFz83sAABQlO69917ZbLZ8jQ0ICNCHH36YY/vOnTtzbMvrnI62XZLq1aun5cuX59geExOj8uXL53kcAAAAADgiZl4BQCkSGxursmXLKi0tLdv2Y8eO6ciRI2rXrp1JyQAAAACgcCivAKCUuXjxogYOHKiTJ0/q6tWr2r59u7p3764yZcpowoQJZscDAAAAgAKhvALg0Dw8PJSammp2jBIjODhYGzZsUHx8vNq0aaOgoCA9+uijqlu3rrZv366QkJACnzPz+/fw8CjquAAAAABwU6x5BcChBQUF6cKFC2bHKFEefPBBPfjgg0V2vgsXLsjb21ve3t5Fdk4AAAAAyC9mXgFwaPXq1dPBgweVnp5udhSntX//ftWrV8/sGAAAAACcFOUVAIfWrFkzJScna/v27WZHcVo//PCDmjVrZnYMAAAAAE6K8gqAQ2vYsKFCQkK0YsUKs6M4pdOnT+u///2vOnfubHYUAAAAAE6K8gqAw+vbt68WLFigpKQks6M4nQ8++EDlypVTx44dzY4CAAAAwElRXgFweP/85z+VnJys6dOnmx3FqcTGxmrWrFn617/+JU9PT7PjAAAAAHBSlFcAHF6lSpU0btw4TZ06VcePHzc7jtMYPXq0AgIC9OKLL5odBQAAAIATo7wCUCK88MILqlatmgYPHiyr1Wp2nFJv3bp1+uSTTzRjxgz5+PiYHQcAAACAE6O8AlAieHh4aOHChdq4caNGjRpldpxSbf/+/erevbt69+6tbt26mR0HAAAAgJOjvAJQYrRs2VLz58/XjBkzNHfuXLPjlEoxMTEKDw9XaGio5s2bZ3YcAAAAAJCb2QEAoCB69uypo0ePasiQITp9+rQmTZoki8VidqxSYffu3Xr00Ufl6+ur5cuXs0g7AAAAAIfAzCsAJc7YsWM1f/58TZ8+XU8++aQuXLhgdqQS74svvlDr1q1Vr149/fTTT6pQoYLZkQAAAABAEuUVgBLqmWee0fr167VlyxbVq1dP7777rjIyMsyOVeLs27dP7du3V48ePdS3b1+tXr1aQUFBZscCAAAAgCyUVwBKrDZt2ig6OlrPPvusIiMj1bhxY7399tuKjY01O5pDS0tL08aNG9WrVy81adJEFy9e1JYtWzRnzhy5u7ubHQ8AAAAAsmHNKwAlWpkyZfTGG2+of//+euONNzRmzBgNGzZMoaGhaty4sSpUqCBvb2+zY5rOarXq4sWLOnLkiHbt2qXLly+refPmmj9/vnr37i0XF/5/GQAAAAAcE+UVgFKhXr16+vDDDzV79mxt2rRJW7du1b59+3Ty5EklJSWZHc90FotFgYGBqlOnjrp166YOHTooJCTE7FgAAAAAcFOUVwBKFR8fH4WHhys8PNzsKAAAAACAIsB1IgAAAAAAAHBYlFcAAAAAAABwWJRXAAAAAAAAcFiUVwAAAAAAAHBYlFcAAAAAAABwWJRXAAAAAAAAcFiUVwAAAAAAAHBYlFcAAAAAAABwWG5mBwDMtGXLFoWEhJgdAyj14uLidO+995odAwAAAEAJRHkFp/X444+rTp06ZscAnEatWrXMjgAAAACgBLLYbDab2SEAAAAAAACAXKxlzSsAAAAAAAA4LMorAAAAAAAAOCzKKwAAAAAAADgsyisAAAAAAAA4LMorAAAAAAAAOCzKKwAAAAAAADgsyisAAAAAAAA4LMorAAAAAAAAOCzKKwAAAAAAADgsyisAAAAAAAA4LMorAAAAAAAAOCzKKwAAAAAAADgsyisAAAAAAAA4LMorAAAAAAAAOCzKKwAAAAAAADgsyisAAFAsEhMTZbFYsj1+/vnnmx43cuTIbMdMmjTJDmmzW7JkSdb7e3l53XR8Sf6sAAAAjs5is9lsZocAAACl1+7du9W0aVNJUseOHfXtt9/mOfbPP/9UzZo1lZiYqN69e2vx4sX2ipmrsLAwbdmyRcnJyfkaX1I/a2Jiopo2bar69evr66+/Ni0HAABALtYy8woAABQ7b29vSdDqvQAAB3dJREFU3XbbbVq9erV27tyZ57iZM2eqevXqdkxW9Mz4rH5+fmrVqlWhj7fZbLJarbJarUWSBwAAoChRXgEAgGLn4uKi0aNHS1Kel8bFx8fr3XffVVRUlD2jFbmS+Fn9/f115MiRG84UAwAAMAvlFQAAsItnn31WVatW1apVq7Rnz54c+9966y116tRJtWvXNiFd0XKmzwoAAFDcKK8AAIBdeHp6auTIkbLZbJo8eXK2fYmJiXr77bc1duzYG57jzz//1PDhw1W7dm15eHgoKChIHTt21ObNm29p7IEDBxQREaGAgAD5+vqqdevW2rJli2mfNT09XUuXLlX79u0VHBwsb29vNW7cWLNnz852ad/06dNlsVh05coVbd26NWvhdzc3N0nSihUrsi0IHx0drSeffFLlypXL2jZv3rxsYzLX92rVqlW27X369JFkrAN27fb4+PhCf08AAAD5QXkFAADsZsCAAapUqZKWLVum/fv3Z22fM2eO2rVrp4YNG+Z5bGxsrJo1a6bPPvtMs2fPVlxcnP773//Kx8dHDz74oObNm1eosYcPH1bLli21c+dOLVu2TGfPntXcuXM1ceJEHTlyxJTPumbNGvXo0UPt2rXT/v37dfLkSQ0YMEDDhw/PdqnhiBEjZLPZ5Ovrq/vvv182m002m03p6emSpIiICNlsNnXp0kWSNHDgQA0aNEgnT57Utm3b5OrqmmNMpi1btmj37t3y9fVVkyZN9P7770uSvvnmG7Vo0UKff/65bDabAgMDC/0dAQAA5AflFQAAsBtvb28NHz5cVqtVU6ZMkf5/O/cT0vQfx3H8ZSE6N/1iWWog5MUgWIP+GZEwGDIiI4OEsIhARDCUEUSZYYdBHQp0RFBevNmlEsKDElKX8ixR5Ig8BFlshWujaaafDtJ++pu/1eYv+x6eD9hh+74+3+/nfRsv9pmkr1+/qre3V93d3RnXdnV1aWpqSn19fWpoaFBJSYlqamo0ODioyspKdXZ26uPHj1lnL1++rJmZGYVCIdXX18vlcsntdmtgYEDT09N/ZVZJ8nq96urqUmlpqcrKytTR0aHm5maFQiF9+fIlpz1dvHhRXq9XRUVFqq2t1ffv31VWVvafeY/Ho4GBAU1MTOjMmTMyxqitrU0+n08nT57MaQ8AAADZorwCAADrqr29XZs3b9a9e/f05s0b3b17VwcOHNCuXbsyrhsaGpIkHTlyZMXnBQUF8vl8SiaTGh0dzTo7MjIiSfL7/Suy27ZtU01NTY5TLsl11oaGhlWPN3o8Hs3Pz+vly5c57Wf//v1Zr2lqalJ3d7cePnyoQ4cO6dOnTwoGgzk9HwAAIBeUVwAAYF25XC4FAgEtLCzo6tWrunnzpq5cuZJxzdzcnGKxmAoLC1VcXJx2vby8XNLSccFss/F4XIWFhXK5XGnZrVu35jJiSi6zSlIsFlNPT4/cbrdKS0tT/y914cIFSUu/4MqF0+nMaV0wGFRtba2eP3+upqYmbdjAV0gAALB++OYBAADWXUdHhyzL0uDgoDwej/bu3ZsxX1BQIMuyNDs7q3g8nnb95xHAioqKrLPFxcWanZ1VIpFIy37+/DmX8VbIdlZJOnr0qILBoFpbWxUOh7W4uChjjHp7eyVJxpgV+by8vDXvM5OnT58qFovJ7Xarvb1dExMTf/R5AAAAy1FeAQCAdWdZls6fPy/Lsn7rl0iSdPz4cUlLfxi+3NzcnMbGxuRwOFJH/7LJHj58WNI/xwd/ikajmpyczHKydNnOurCwoGfPnqmiokKdnZ3asmVLqpxKJpOrrikqKtK3b99S73fs2KH+/v41712Spqam1NLSogcPHujRo0dyOBw6duyYIpHI/3J/AACAX6G8AgAAf0VPT49mZmZ08ODB38pfv35d1dXVCgQCGh4eVjweVzgcVnNzs6anpxUKhVJHArPJXrt2TZs2bVIgENDjx4+VSCT06tUrnT59etWjhH961o0bN8rr9erDhw+6ceOGotGoksmknjx5ojt37qy6Zvfu3QqHw3r37p3Gx8f19u1b1dXVrXnfiURCjY2N6uvr086dO7V9+3bdv39f79+/14kTJzQ/P7/mZwAAAPySAQAA+EOcTqeRlHr5/f6M+eXZn69bt26lrkejURMIBEx1dbXJz883lmUZv99vxsbG0u6VTXZyctI0NjaakpIS43A4zL59+8zw8LDx+XypfbS0tKzbrJFIxLS1tZmqqiqTn59vysvLzdmzZ82lS5dS2T179qTu9fr1a1NXV2ecTqepqqoyt2/fNsYYMz4+vupzlhsaGkq7furUKXPu3LkVn7148cJEIpG0bDAYzDgnAADAGo3kGfOvP00AAAAAAAAA7GGUY4MAAAAAAACwLcorAAAAAAAA2BblFQAAAAAAAGyL8goAAAAAAAC2RXkFAAAAAAAA26K8AgAAAAAAgG1RXgEAAAAAAMC2KK8AAAAAAABgW5RXAAAAAAAAsC3KKwAAAAAAANgW5RUAAAAAAABsi/IKAAAAAAAAtkV5BQAAAAAAANuivAIAAAAAAIBt/QBfU4L8gygxGQAAAABJRU5ErkJggg==\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.9.0/transitions.egg-info/ 0000755 0002322 0002322 00000000000 14304350474 020516 5 ustar debalance debalance transitions-0.9.0/transitions.egg-info/requires.txt 0000644 0002322 0002322 00000000052 14304350474 023113 0 ustar debalance debalance six
[diagrams]
pygraphviz
[test]
pytest
transitions-0.9.0/transitions.egg-info/PKG-INFO 0000644 0002322 0002322 00000240373 14304350474 021624 0 ustar debalance debalance Metadata-Version: 2.1
Name: transitions
Version: 0.9.0
Summary: A lightweight, object-oriented Python state machine implementation with many extensions.
Home-page: http://github.com/pytransitions/transitions
Download-URL: https://github.com/pytransitions/transitions/archive/0.9.0.tar.gz
Author: Tal Yarkoni
Author-email: tyarkoni@gmail.com
Maintainer: Alexander Neumann
Maintainer-email: aleneum@gmail.com
License: MIT
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Description-Content-Type: text/markdown
Provides-Extra: diagrams
Provides-Extra: test
License-File: LICENSE
## 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`:
```python
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.
#### Check transitions
If you want to check whether a transition is possible before you execute it ('look before you leap'), you can use `may_` convenience functions that have been attached to your model:
```python
# check if the current temperature is hot enough to trigger a transition
if lump.may_heat():
lump.heat()
```
This will execute all `prepare` callbacks and evaluate the conditions assigned to the potential transitions.
Transition checks can also be used when a transition's destination is not available (yet):
```python
machine.add_transition('elevate', 'solid', 'spiritual')
assert not lump.may_elevate() # not ready yet :(
```
#### 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 `asyncio.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.9.0/transitions.egg-info/SOURCES.txt 0000644 0002322 0002322 00000003501 14304350474 022401 0 ustar debalance debalance .coveragerc
.pylintrc
Changelog.md
LICENSE
MANIFEST.in
README.md
conftest.py
mypy.ini
pytest.ini
requirements.txt
requirements_diagrams.txt
requirements_mypy.txt
requirements_test.txt
setup.cfg
setup.py
tox.ini
binder/apt.txt
binder/postBuild
binder/requirements.txt
examples/Frequently asked questions.ipynb
examples/Graph MIxin Demo Nested.ipynb
examples/Graph MIxin Demo.ipynb
examples/Playground.ipynb
tests/__init__.py
tests/test_add_remove.py
tests/test_async.py
tests/test_codestyle.py
tests/test_core.py
tests/test_enum.py
tests/test_factory.py
tests/test_graphviz.py
tests/test_markup.py
tests/test_nesting.py
tests/test_parallel.py
tests/test_pygraphviz.py
tests/test_reuse.py
tests/test_states.py
tests/test_threading.py
tests/utils.py
transitions/__init__.py
transitions/__init__.pyi
transitions/core.py
transitions/core.pyi
transitions/py.typed
transitions/version.py
transitions/version.pyi
transitions.egg-info/PKG-INFO
transitions.egg-info/SOURCES.txt
transitions.egg-info/dependency_links.txt
transitions.egg-info/requires.txt
transitions.egg-info/top_level.txt
transitions/extensions/__init__.py
transitions/extensions/asyncio.py
transitions/extensions/asyncio.pyi
transitions/extensions/diagrams.py
transitions/extensions/diagrams.pyi
transitions/extensions/diagrams_base.py
transitions/extensions/diagrams_base.pyi
transitions/extensions/diagrams_graphviz.py
transitions/extensions/diagrams_graphviz.pyi
transitions/extensions/diagrams_pygraphviz.py
transitions/extensions/diagrams_pygraphviz.pyi
transitions/extensions/factory.py
transitions/extensions/factory.pyi
transitions/extensions/locking.py
transitions/extensions/locking.pyi
transitions/extensions/markup.py
transitions/extensions/markup.pyi
transitions/extensions/nesting.py
transitions/extensions/nesting.pyi
transitions/extensions/states.py
transitions/extensions/states.pyi transitions-0.9.0/transitions.egg-info/top_level.txt 0000644 0002322 0002322 00000000014 14304350474 023243 0 ustar debalance debalance transitions
transitions-0.9.0/transitions.egg-info/dependency_links.txt 0000644 0002322 0002322 00000000001 14304350474 024564 0 ustar debalance debalance
transitions-0.9.0/pytest.ini 0000644 0002322 0002322 00000000175 14304350474 016503 0 ustar debalance debalance [pytest]
filterwarnings =
error
ignore:.*With-statements.*:DeprecationWarning
addopts = -x -rf
junit_family = xunit2
transitions-0.9.0/requirements_test.txt 0000644 0002322 0002322 00000000114 14304350474 020766 0 ustar debalance debalance pytest
pytest-cov
pytest-runner
pytest-xdist
mock
dill
graphviz
pycodestyle
transitions-0.9.0/requirements_mypy.txt 0000644 0002322 0002322 00000000030 14304350474 021002 0 ustar debalance debalance mypy
graphviz
types-six
transitions-0.9.0/.pylintrc 0000644 0002322 0002322 00000035102 14304350474 016315 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,
too-few-public-methods,
super-with-arguments,
useless-object-inheritance,
raise-missing-from
# 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.9.0/tests/ 0000755 0002322 0002322 00000000000 14304350474 015611 5 ustar debalance debalance transitions-0.9.0/tests/utils.py 0000644 0002322 0002322 00000005115 14304350474 017325 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 self.message is None:
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.9.0/tests/test_pygraphviz.py 0000644 0002322 0002322 00000007565 14304350474 021442 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): # type: ignore
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.9.0/tests/test_states.py 0000644 0002322 0002322 00000014077 14304350474 020536 0 ustar debalance debalance from transitions import Machine, MachineError
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 # type: ignore
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): # type: ignore
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.9.0/tests/test_factory.py 0000644 0002322 0002322 00000003650 14304350474 020675 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.9.0/tests/__init__.py 0000644 0002322 0002322 00000000000 14304350474 017710 0 ustar debalance debalance transitions-0.9.0/tests/test_async.py 0000644 0002322 0002322 00000051104 14304350474 020340 0 ustar debalance debalance from transitions.extensions.asyncio import AsyncMachine, HierarchicalAsyncMachine
from transitions.extensions.factory import AsyncGraphMachine, HierarchicalAsyncGraphMachine
try:
import asyncio
except (ImportError, SyntaxError):
asyncio = None # type: ignore
from unittest.mock import MagicMock
from unittest import skipIf
from functools import partial
import weakref
from .test_core import TestTransitions, MachineError, TYPE_CHECKING
from .utils import DummyModel
from .test_graphviz import pgv as gv
from .test_pygraphviz import pgv
if TYPE_CHECKING:
from typing import Type
@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 = AsyncMachine # type: Type[AsyncMachine]
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()
self.machine_cls = HierarchicalAsyncMachine
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): # type: ignore
pass
states = ['A',
{'name': 'B', 'timeout': 0.2, 'on_timeout': ['to_C', timeout_called]},
{'name': 'C', 'timeout': 0, 'on_timeout': 'to_D'}, 'D']
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)
m.get_state('C').timeout = 0.05
await m.to_B()
await asyncio.sleep(0.3)
self.assertTrue(m.is_D())
self.assertEqual(2, timeout_called.call_count)
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, MachineError))
mock()
m = self.machine_cls(states=['A', 'B'], initial='A', transitions=[['go', 'A', 'B']], 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()
await m.go()
self.assertTrue(mock.called)
self.assertEqual(2, mock.call_count)
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())
def test_may_transition_with_auto_transitions(self):
states = ['A', 'B', 'C']
d = DummyModel()
self.machine_cls(model=d, states=states, initial='A')
async def run():
assert await d.may_to_A()
assert await d.may_to_B()
assert await d.may_to_C()
asyncio.run(run())
def test_machine_may_transitions(self):
states = ['A', 'B', 'C']
m = self.machine_cls(states=states, initial='A', auto_transitions=False)
m.add_transition('walk', 'A', 'B', conditions=[lambda: False])
m.add_transition('stop', 'B', 'C')
m.add_transition('run', 'A', 'C')
async def run():
assert not await m.may_walk()
assert not await m.may_stop()
assert await m.may_run()
await m.run()
assert not await m.may_run()
assert not await m.may_stop()
assert not await m.may_walk()
asyncio.run(run())
def test_may_transition_with_invalid_state(self):
states = ['A', 'B', 'C']
d = DummyModel()
m = self.machine_cls(model=d, states=states, initial='A', auto_transitions=False)
m.add_transition('walk', 'A', 'UNKNOWN')
async def run():
assert not await d.may_walk()
asyncio.run(run())
@skipIf(asyncio is None or (pgv is None and gv is None), "AsyncGraphMachine requires asyncio and (py)gaphviz")
class TestAsyncGraphMachine(TestAsync):
def setUp(self):
super(TestAsync, self).setUp()
self.machine_cls = AsyncGraphMachine # type: Type[AsyncGraphMachine]
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 = HierarchicalAsyncMachine # type: Type[HierarchicalAsyncMachine]
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 TestAsyncHierarchicalGraphMachine(TestHierarchicalAsync):
def setUp(self):
super(TestHierarchicalAsync, self).setUp()
self.machine_cls = HierarchicalAsyncGraphMachine # type: Type[HierarchicalAsyncGraphMachine]
self.machine = self.machine_cls(states=['A', 'B', 'C'], transitions=[['go', 'A', 'B']], initial='A')
transitions-0.9.0/tests/test_codestyle.py 0000644 0002322 0002322 00000003125 14304350474 021216 0 ustar debalance debalance import unittest
import subprocess
from os.path import exists
import pycodestyle
try:
import mypy
except ImportError:
mypy = None # type: ignore
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).")
@unittest.skipIf(mypy is None, "mypy not found")
def test_mypy_package(self):
call = ['mypy', '--config-file', 'mypy.ini', 'transitions']
# when run from root directory (e.g. tox) else when run from test directory (e.g. pycharm)
project_root = '.' if exists('transitions') else '..'
subprocess.check_call(call, cwd=project_root)
@unittest.skipIf(mypy is None, "mypy not found")
def test_mypy_tests(self):
call = ['mypy', 'tests',
'--disable-error-code', 'attr-defined',
'--disable-error-code', 'no-untyped-def']
# when run from root directory (e.g. tox) else when run from test directory (e.g. pycharm)
project_root = '.' if exists('transitions') else '..'
subprocess.check_call(call, cwd=project_root)
transitions-0.9.0/tests/test_core.py 0000644 0002322 0002322 00000134435 14304350474 020164 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
import sys
from typing import TYPE_CHECKING
from functools import partial
from unittest import TestCase, skipIf
import weakref
from transitions import Machine, MachineError, State, EventData
from transitions.core import listify, _prep_ordered_arg
from .utils import InheritedStuff
from .utils import Stuff, DummyModel
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock # type: ignore
if TYPE_CHECKING:
from typing import List, Union, Dict, Callable
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'}
] # type: List[Union[List[str], Dict[str, str]]]
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 is not None and 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...')
self.assertIn('I am F!', s.message or "")
self.assertIn('Hello F!', s.message or "")
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 is not None and s.message.startswith('Hallo.'))
s.to_A()
s.advance('Test as positional argument')
self.assertTrue(s.message is not None and 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 is not None and 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')] # type: List[Union[str, Dict[str, str], State]]
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)
self.assertEqual(before_state_change, m.before_state_change[0])
self.assertEqual(after_state_change, m.after_state_change[0])
m.to_B()
self.assertTrue(before_state_change.called)
self.assertTrue(after_state_change.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.assertTrue(isinstance(m.model, list) and 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(4, finalize_mock.call_count)
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):
# deliberately passing wrong arguments
_prep_ordered_arg(3, [None, None]) # type: ignore
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, MachineError))
mock()
m = self.machine_cls(states=['A', 'B'], initial='A', transitions=[['go', 'A', 'B']], send_event=True,
after_state_change=partial(self.stuff.this_raises, ValueError))
with self.assertRaises(ValueError):
m.to_B()
self.assertTrue(m.is_B())
with self.assertRaises(MachineError):
m.go()
m.on_exception.append(on_exception)
m.to_B()
m.go()
self.assertTrue(mock.called)
self.assertEqual(2, mock.call_count)
def test_may_transition(self):
states = ['A', 'B', 'C']
d = DummyModel()
m = Machine(model=d, states=states, initial='A', auto_transitions=False)
m.add_transition('walk', 'A', 'B')
m.add_transition('stop', 'B', 'C')
assert d.may_walk()
assert not d.may_stop()
d.walk()
assert not d.may_walk()
assert d.may_stop()
def test_may_transition_for_autogenerated_triggers(self):
states = ['A', 'B', 'C']
m = Machine(states=states, initial='A')
assert m.may_to_A()
m.to_A()
assert m.to_B()
m.to_B()
assert m.may_to_C()
m.to_C()
def test_may_transition_with_conditions(self):
states = ['A', 'B', 'C']
d = DummyModel()
m = Machine(model=d, states=states, initial='A', auto_transitions=False)
m.add_transition('walk', 'A', 'B', conditions=[lambda: False])
m.add_transition('stop', 'B', 'C')
m.add_transition('run', 'A', 'C')
assert not d.may_walk()
assert not d.may_stop()
assert d.may_run()
d.run()
assert not d.may_run()
def test_may_transition_with_auto_transitions(self):
states = ['A', 'B', 'C']
d = DummyModel()
self.machine_cls(model=d, states=states, initial='A')
assert d.may_to_A()
assert d.may_to_B()
assert d.may_to_C()
def test_machine_may_transitions(self):
states = ['A', 'B', 'C']
m = self.machine_cls(states=states, initial='A', auto_transitions=False)
m.add_transition('walk', 'A', 'B', conditions=[lambda: False])
m.add_transition('stop', 'B', 'C')
m.add_transition('run', 'A', 'C')
m.add_transition('reset', 'C', 'A')
assert not m.may_walk()
assert not m.may_stop()
assert m.may_run()
m.run()
assert not m.may_run()
assert not m.may_stop()
assert not m.may_walk()
def test_may_transition_with_invalid_state(self):
states = ['A', 'B', 'C']
d = DummyModel()
m = self.machine_cls(model=d, states=states, initial='A', auto_transitions=False)
m.add_transition('walk', 'A', 'UNKNOWN')
assert not d.may_walk()
transitions-0.9.0/tests/test_markup.py 0000644 0002322 0002322 00000017374 14304350474 020535 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from functools import partial
from transitions.extensions.markup import MarkupMachine, HierarchicalMarkupMachine, rep
from .test_core import TYPE_CHECKING
from .utils import Stuff
from unittest import TestCase, skipIf
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock # type: ignore
try:
import enum
from enum import Enum
except ImportError:
enum = None # type: ignore
# placeholder for Python < 3.4 without enum
class Enum: # type: ignore
pass
if TYPE_CHECKING:
from typing import List, Dict, Type, Union
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'] # type: Union[List[Union[str, Dict]], Type[Enum]]
self.transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
] # type: List[Union[str, Dict[str, Union[str, Enum]]]]
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['transitions']), self.num_trans)
self.assertEqual(len(m2.markup['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['transitions']), self.num_trans)
self.assertEqual(len(m2.markup['transitions']), self.num_trans + self.num_auto)
m1.auto_transitions_markup = True
m2.auto_transitions_markup = False
self.assertEqual(len(m1.markup['transitions']), self.num_trans + self.num_auto)
self.assertEqual(len(m2.markup['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'}] # type: List[Dict]
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.9.0/tests/test_threading.py 0000644 0002322 0002322 00000025026 14304350474 021174 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
import time
from threading import Thread
import logging
from transitions.extensions import LockedHierarchicalMachine, LockedMachine
from .test_nesting import TestNestedTransitions
from .test_core import TestTransitions, TYPE_CHECKING
from .utils import Stuff, DummyModel, SomeContext
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock # type: ignore
if TYPE_CHECKING:
from typing import List, Type, Tuple, Any
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(TestTransitions):
def setUp(self):
self.machine_cls = LockedMachine # type: Type[LockedMachine]
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 = LockedMachine
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(TestTransitions):
def setUp(self):
self.event_list = [] # type: List[Tuple[Any, str]]
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 = LockedMachine # type: Type[LockedMachine]
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(TestNestedTransitions, TestLockedTransitions):
def setUp(self):
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', {'name': '3', 'children': ['a', 'b', 'c']}]},
'D', 'E', 'F']
self.machine_cls = LockedHierarchicalMachine # type: Type[LockedHierarchicalMachine]
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): # type: ignore
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.9.0/tests/test_graphviz.py 0000644 0002322 0002322 00000044004 14304350474 021056 0 ustar debalance debalance try:
from builtins import object
except ImportError:
pass
from .utils import Stuff, DummyModel
from .test_core import TestTransitions, TYPE_CHECKING
from transitions.extensions import (
LockedGraphMachine, GraphMachine, HierarchicalGraphMachine, LockedHierarchicalGraphMachine
)
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
if TYPE_CHECKING:
from typing import Type, List, Collection, Union
@skipIf(pgv is None, 'Graph diagram test requires graphviz.')
class TestDiagrams(TestTransitions):
machine_cls = GraphMachine # type: Type[GraphMachine]
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'] # type: List[Union[str, Collection[str]]]
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
match = re.match(r'\[label=([^\]]+)\]', e)
self.assertIsNotNone(match and getattr(m, match.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(0, len(edges))
self.assertIn(r'label="A\l"', 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(r'label="A\l"', 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): # type: ignore
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): # type: ignore
def __init__(self, *args, **kwargs):
self.label = kwargs.pop('label')
super(LabelState, self).__init__(*args, **kwargs)
class CustomMachine(self.machine_cls): # type: ignore
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(r'label="LabelA\l"', dot)
self.assertIn(r'label="NotLabelA\l"', dot)
self.assertIn("label=LabelEvent", dot)
self.assertNotIn(r'label="A\l"', 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()
def test_graphviz_fallback(self):
try:
from unittest import mock # will raise an ImportError in Python 2.7
from transitions.extensions.diagrams_graphviz import Graph
from transitions.extensions import diagrams_pygraphviz
from importlib import reload
with mock.patch.dict('sys.modules', {'pygraphviz': None}):
# load and reload diagrams_pygraphviz to make sure
# an ImportError is raised for pygraphviz
reload(diagrams_pygraphviz)
m = self.machine_cls(states=['A', 'B', 'C'], initial='A', use_pygraphviz=True)
# make sure to reload after test is done to avoid side effects with other tests
reload(diagrams_pygraphviz)
print(m.graph_cls, pgv)
self.assertTrue(issubclass(m.graph_cls, Graph))
except ImportError:
pass
@skipIf(pgv is None, 'Graph diagram test requires graphviz')
class TestDiagramsLocked(TestDiagrams):
machine_cls = LockedGraphMachine # type: Type[LockedGraphMachine]
@skipIf(pgv is None, 'NestedGraph diagram test requires graphviz')
class TestDiagramsNested(TestDiagrams):
machine_cls = HierarchicalGraphMachine \
# type: Type[HierarchicalGraphMachine | LockedHierarchicalGraphMachine]
def setUp(self):
super(TestDiagramsNested, self).setUp()
self.states = ['A', 'B',
{'name': 'C', 'children': [{'name': '1', 'children': ['a', 'b', 'c']},
'2', '3']}, 'D'] # type: List[Union[str, Collection[str]]]
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): # type: ignore
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 = LockedHierarchicalGraphMachine # type: Type[LockedHierarchicalGraphMachine]
transitions-0.9.0/tests/test_nesting.py 0000644 0002322 0002322 00000112413 14304350474 020673 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 functools import partial
from transitions.extensions.nesting import NestedState, HierarchicalMachine
from transitions.extensions import HierarchicalGraphMachine
from unittest import skipIf
from .test_core import TestTransitions, TestCase, TYPE_CHECKING
from .utils import Stuff, DummyModel
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock # type: ignore
try:
# Just to skip tests if graphviz not installed
import graphviz as pgv # @UnresolvedImport
except ImportError: # pragma: no cover
pgv = None
if TYPE_CHECKING:
from typing import List, Dict, Union, Type
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 = HierarchicalMachine # type: Type[HierarchicalMachine]
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}
] # type: List[Union[List[str], Dict[str, str]]]
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': []}] # type: List[Dict[str, Union[str, List[Dict]]]]
curr = states[0] # type: Dict
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):
exit_mock = MagicMock()
enter_mock = MagicMock()
class CustomMachine(self.machine_cls): # type: ignore
def on_enter_A(self):
raise AssertionError("on_enter_A must not be called!")
def on_exit_A(self):
raise AssertionError("on_exit_A must not be called!")
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(exit_mock.called)
self.assertFalse(enter_mock.called)
machine.go()
self.assertTrue(exit_mock.called)
self.assertTrue(enter_mock.called)
machine.go()
self.assertEqual(2, enter_mock.call_count)
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): # type: ignore
state_cls = State
class MyNestedState(NestedState):
pass
class CorrectStateClass(self.machine_cls): # type: ignore
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()
def test_machine_may_transitions_for_generated_triggers(self):
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D']
m = self.stuff.machine_cls(states=states, initial='A')
assert m.may_to_A()
m.to_A()
assert m.may_to_B()
m.to_B()
assert m.may_to_C()
m.to_C()
assert m.may_to_C_1()
m.to_C_1()
assert m.may_to_D()
m.to_D()
def test_get_nested_triggers(self):
transitions = [
['goB', 'A', 'B'],
['goC', 'B', 'C'],
['goA', '*', 'A'],
['goF1', ['C{0}1'.format(self.machine_cls.separator), 'C{0}2'.format(self.machine_cls.separator)], 'F'],
['goF2', 'C', 'F']
]
m = self.machine_cls(states=test_states, transitions=transitions, auto_transitions=False, initial='A')
self.assertEqual(1, len(m.get_nested_triggers(['C', '1'])))
with m('C'):
m.add_transition('goC1', '1', '2')
self.assertEqual(len(transitions) + 1, len(m.get_nested_triggers()))
self.assertEqual(2, len(m.get_nested_triggers(['C', '1'])))
self.assertEqual(2, len(m.get_nested_triggers(['C'])))
def test_stop_transition_evaluation(self):
states = ['A', {'name': 'B', 'states': ['C', 'D']}]
transitions = [['next', 'A', 'B_C'], ['next', 'B_C', 'B_D'], ['next', 'B', 'A']]
mock = MagicMock()
def process_error(event_data):
assert isinstance(event_data.error, ValueError)
mock()
m = self.machine_cls(states=states, transitions=transitions, initial='A', send_event=True)
m.on_enter_B_D(partial(self.stuff.this_raises, ValueError()))
m.next()
with self.assertRaises(ValueError):
m.next()
assert m.is_B_D()
assert m.to_B_C()
m.on_exception = [process_error]
m.next()
assert mock.called
assert m.is_B_D()
def test_nested_queued_remap(self):
states = ['A', 'done',
{'name': 'B', 'remap': {'done': 'done'},
'initial': 'initial',
'transitions': [['go', 'initial', 'a']],
'states': ['done', 'initial', {'name': 'a', 'remap': {'done': 'done'},
'initial': 'initial',
'transitions': [['go', 'initial', 'x']],
'states': ['done', 'initial',
{'name': 'x',
'remap': {'done': 'done'},
'initial': 'initial',
'states': ['initial', 'done'],
'transitions': [['done', 'initial', 'done']]}]}]}]
m = self.machine_cls(states=states, initial='A', queued=True)
m.on_enter_B('go')
m.on_enter_B_a('go')
m.on_enter_B_a_x_initial('done')
m.to_B()
assert m.is_done()
# https://github.com/pytransitions/transitions/issues/568
def test_wildcard_src_reflexive_dest(self):
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D']
machine = self.machine_cls(states=states, transitions=[["reflexive", "*", "="]], initial="A")
self.assertTrue(machine.is_A())
machine.reflexive()
self.assertTrue(machine.is_A())
state_name = 'C{0}2'.format(self.state_cls.separator)
machine.set_state(state_name)
self.assertEqual(state_name, machine.state)
machine.reflexive()
self.assertEqual(state_name, machine.state)
class TestSeparatorsBase(TestCase):
separator = default_separator
def setUp(self):
class CustomNestedState(NestedState):
separator = self.separator
class CustomHierarchicalMachine(HierarchicalMachine):
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 is not None and s.message.startswith('Nice to'))
s.reverse()
self.assertEqual(s.state, 'A')
self.assertTrue(s.message is not None and 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 is not None and 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):
class CustomHierarchicalGraphMachine(HierarchicalGraphMachine):
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)
def test_machine_may_transitions(self):
states = ['A', 'B', {'name': 'C', 'children': ['1', '2', '3']}, 'D']
transitions = [
{'trigger': 'walk', 'source': 'A', 'dest': 'B'},
{'trigger': 'run', 'source': 'B', 'dest': 'C'},
{'trigger': 'run_fast', 'source': 'C', 'dest': 'C{0}1'.format(self.separator)},
{'trigger': 'sprint', 'source': 'C', 'dest': 'D'}
]
m = self.stuff.machine_cls(
states=states, transitions=transitions, initial='A', auto_transitions=False
)
assert m.may_walk()
assert not m.may_run()
assert not m.may_run_fast()
assert not m.may_sprint()
m.walk()
assert not m.may_walk()
assert m.may_run()
assert not m.may_run_fast()
m.run()
assert m.may_run_fast()
assert m.may_sprint()
m.run_fast()
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.9.0/tests/test_parallel.py 0000644 0002322 0002322 00000020542 14304350474 021021 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 # type: ignore
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.9.0/tests/test_enum.py 0000644 0002322 0002322 00000033343 14304350474 020174 0 ustar debalance debalance from unittest import TestCase, skipIf
from transitions.core import Machine
from transitions.extensions.diagrams import GraphMachine, HierarchicalGraphMachine
from transitions.extensions.nesting import HierarchicalMachine
try:
import enum
except ImportError:
enum = None # type: ignore
from .test_core import TYPE_CHECKING
from .test_pygraphviz import pgv
from .test_graphviz import pgv as gv
if TYPE_CHECKING:
from typing import Type, List, Union, Dict
@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 = Machine
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)
def test_may_transition(self):
class TrafficLight(object):
pass
t = TrafficLight()
m = Machine(states=self.States, model=t, initial=self.States.RED, auto_transitions=False)
m.add_transition('go', self.States.RED, self.States.GREEN)
m.add_transition('stop', self.States.YELLOW, self.States.RED)
assert t.may_go()
assert not t.may_stop()
@skipIf(enum is None, "enum is not available")
class TestNestedStateEnums(TestEnumsAsStates):
def setUp(self):
super(TestNestedStateEnums, self).setUp()
self.machine_cls = HierarchicalMachine # type: Type[HierarchicalMachine]
def test_root_enums(self):
states = [self.States.RED, self.States.YELLOW,
{'name': self.States.GREEN, 'children': ['tick', 'tock'], 'initial': 'tick'}] \
# type: List[Union[enum.Enum, Dict]]
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}] \
# type: List[Union[str, enum.Enum,Dict]]
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): # type: ignore
separator = '.'
# make custom machine use custom state with dot separator
class DotMachine(self.machine_cls): # type: ignore
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 = GraphMachine # type: Type[GraphMachine]
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 = HierarchicalGraphMachine
def test_invalid_enum_path(self):
class States(enum.Enum):
ONE = 1
TWO = 2
THREE = 3
class Invalid(enum.Enum):
INVALID = 1
with self.assertRaises(ValueError):
self.machine_cls(states=States, transitions=[['go', '*', Invalid.INVALID]], initial=States.ONE)
transitions-0.9.0/tests/test_reuse.py 0000644 0002322 0002322 00000040623 14304350474 020352 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, HierarchicalMachine
from .utils import Stuff
from .test_core import TYPE_CHECKING
from unittest import TestCase
try:
from unittest.mock import MagicMock
except ImportError:
from mock import MagicMock # type: ignore
if TYPE_CHECKING:
from typing import List, Union, Dict, Any
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(HierarchicalMachine):
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 = HierarchicalMachine
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'}}] \
# type: List[Union[str, Dict[str, Union[str, Dict, List]]]]
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'}}] \
# type: List[Union[str, Dict[str, Union[str, HierarchicalMachine, Dict]]]]
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 # type: ignore
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): # type: ignore
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): # type: ignore
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"
} # type: Dict[str, Any]
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())
def test_reuse_wrong_class(self):
m1 = MachineFactory.get_predefined()(states=['A', 'B'], initial='A')
with self.assertRaises(ValueError):
m2 = MachineFactory.get_predefined(nested=True)(states=['X', {'name': 'Y', 'states': m1}], initial='Y')
def test_reuse_remap(self):
class GenericMachine(self.machine_cls): # type: ignore
def __init__(self, states, transitions, model=None):
generic_states = [
{"name": "initial", "on_enter": self.entry_initial},
{"name": "done", "on_enter": self.entry_done},
]
states += generic_states
super(GenericMachine, self).__init__(
states=states,
transitions=transitions,
model=model,
send_event=True,
queued=True,
auto_transitions=False
)
def entry_initial(self, event_data):
raise NotImplementedError
def entry_done(self, event_data):
raise NotImplementedError
class DeeperMachine(GenericMachine):
def __init__(self):
states = [
{"name": "working", "on_enter": self.entry_working},
]
transitions = [
["go", "initial", "working"],
["go", "working", "done"],
]
super(DeeperMachine, self).__init__(states, transitions, model=self)
def entry_initial(self, event_data):
event_data.model.go()
def entry_working(self, event_data):
event_data.model.go()
class NestedMachine(GenericMachine):
def __init__(self):
states = [
{"name": "deeper", "children": DeeperMachine(), "remap": {"done": "done"}},
]
transitions = [
["go", "initial", "deeper"],
]
super(NestedMachine, self).__init__(states, transitions)
def entry_initial(self, event_data):
event_data.model.go()
class MainMachine(GenericMachine):
def __init__(self):
states = [
{"name": "nested", "children": NestedMachine(), "remap": {"done": "done"}},
]
transitions = [
["go", "initial", "nested"],
]
super(MainMachine, self).__init__(states, transitions, model=self)
def entry_done(self, event_data):
print("job finished")
machine = MainMachine()
machine.go()
assert machine.is_done()
def test_reuse_callback_copy(self):
selfs = []
class Model(object):
def check_self(self):
selfs.append(self)
return True
m = Model()
transitions = [
{"trigger": "go", "source": "A", "dest": "B",
"conditions": m.check_self, "prepare": m.check_self, "before": m.check_self, "after": m.check_self}
]
child = self.machine_cls(None, states=["A", "B"], transitions=transitions, initial="A")
parent = self.machine_cls(m, states=[{"name": "P", "states": child, "remap": {}}], initial="P")
m.go()
self.assertEqual("P_B", m.state)
# selfs should only contain references to the same model. If the set is larger than one this means
# that at some poin the model was falsely copied.
self.assertEqual(1, len(set(selfs)))
transitions-0.9.0/tests/test_add_remove.py 0000644 0002322 0002322 00000005201 14304350474 021325 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.9.0/tox.ini 0000644 0002322 0002322 00000001233 14304350474 015761 0 ustar debalance debalance [tox]
envlist = mypy, 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:mypy]
basepython = python3.10
deps = -rrequirements.txt
-rrequirements_diagrams.txt
-rrequirements_mypy.txt
commands = mypy transitions
[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