text stringlengths 0 1.05M | meta dict |
|---|---|
"""Add initial length limits
Revision ID: dddf9a5cdd08
Revises: 8cde5e07b63f
Create Date: 2018-03-10 12:20:17.091148
"""
# revision identifiers, used by Alembic.
revision = 'dddf9a5cdd08'
down_revision = '8cde5e07b63f'
from alembic import op # lgtm[py/unused-import]
import sqlalchemy as sa # lgtm[py/unused-import]
def upgrade():
op.execute("UPDATE journalcomment SET content = substring(content for 10000) WHERE length(content) > 10000")
op.execute("UPDATE searchtag SET title = substring(title for 162) WHERE length(title) > 162")
op.alter_column('ads', 'owner',
existing_type=sa.TEXT(),
type_=sa.String(length=254),
existing_nullable=False)
op.alter_column('character', 'content',
existing_type=sa.TEXT(),
type_=sa.String(length=100000),
existing_nullable=False,
existing_server_default=sa.text(u"''::text"))
op.alter_column('charcomment', 'content',
existing_type=sa.TEXT(),
type_=sa.String(length=10000),
existing_nullable=False)
op.alter_column('commishdesc', 'content',
existing_type=sa.VARCHAR(),
type_=sa.String(length=20000),
existing_nullable=False)
op.alter_column('journal', 'content',
existing_type=sa.TEXT(),
type_=sa.String(length=100000),
existing_nullable=False)
op.alter_column('journalcomment', 'content',
existing_type=sa.TEXT(),
type_=sa.String(length=10000),
existing_nullable=False)
op.alter_column('message', 'content',
existing_type=sa.TEXT(),
type_=sa.String(length=100000),
existing_nullable=False)
op.alter_column('premiumpurchase', 'email',
existing_type=sa.VARCHAR(),
type_=sa.String(length=254),
existing_nullable=False)
op.alter_column('profile', 'profile_text',
existing_type=sa.TEXT(),
type_=sa.String(length=100000),
existing_nullable=False,
existing_server_default=sa.text(u"''::text"))
op.alter_column('profile', 'stream_text',
existing_type=sa.VARCHAR(),
type_=sa.String(length=2000),
existing_nullable=True)
op.alter_column('searchtag', 'title',
existing_type=sa.TEXT(),
type_=sa.String(length=162),
existing_nullable=False)
op.alter_column('submission', 'content',
existing_type=sa.TEXT(),
type_=sa.String(length=300000),
existing_nullable=False)
op.alter_column('user_links', 'link_value',
existing_type=sa.VARCHAR(),
type_=sa.String(length=2000),
existing_nullable=False)
def downgrade():
op.alter_column('user_links', 'link_value',
existing_type=sa.String(length=2000),
type_=sa.VARCHAR(),
existing_nullable=False)
op.alter_column('submission', 'content',
existing_type=sa.String(length=300000),
type_=sa.TEXT(),
existing_nullable=False)
op.alter_column('searchtag', 'title',
existing_type=sa.String(length=162),
type_=sa.TEXT(),
existing_nullable=False)
op.alter_column('profile', 'stream_text',
existing_type=sa.String(length=2000),
type_=sa.VARCHAR(),
existing_nullable=True)
op.alter_column('profile', 'profile_text',
existing_type=sa.String(length=100000),
type_=sa.TEXT(),
existing_nullable=False,
existing_server_default=sa.text(u"''::text"))
op.alter_column('premiumpurchase', 'email',
existing_type=sa.String(length=254),
type_=sa.VARCHAR(),
existing_nullable=False)
op.alter_column('message', 'content',
existing_type=sa.String(length=100000),
type_=sa.TEXT(),
existing_nullable=False)
op.alter_column('journalcomment', 'content',
existing_type=sa.String(length=10000),
type_=sa.TEXT(),
existing_nullable=False)
op.alter_column('journal', 'content',
existing_type=sa.String(length=100000),
type_=sa.TEXT(),
existing_nullable=False)
op.alter_column('commishdesc', 'content',
existing_type=sa.String(length=20000),
type_=sa.VARCHAR(),
existing_nullable=False)
op.alter_column('charcomment', 'content',
existing_type=sa.String(length=10000),
type_=sa.TEXT(),
existing_nullable=False)
op.alter_column('character', 'content',
existing_type=sa.String(length=100000),
type_=sa.TEXT(),
existing_nullable=False,
existing_server_default=sa.text(u"''::text"))
op.alter_column('ads', 'owner',
existing_type=sa.String(length=254),
type_=sa.TEXT(),
existing_nullable=False)
| {
"repo_name": "Weasyl/weasyl",
"path": "libweasyl/libweasyl/alembic/versions/dddf9a5cdd08_add_initial_length_limits.py",
"copies": "1",
"size": "5269",
"license": "apache-2.0",
"hash": -4570414465705857500,
"line_mean": 39.2213740458,
"line_max": 112,
"alpha_frac": 0.5585500095,
"autogenerated": false,
"ratio": 4.0406441717791415,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.015386166922869248,
"num_lines": 131
} |
"""Add initial models
Revision ID: 2241ef954d7f
Revises: None
Create Date: 2013-07-06 19:02:12.980884
"""
revision = '2241ef954d7f'
down_revision = None
from alembic import op
import sqlalchemy as sa
def upgrade():
op.create_table(
'category',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('name', sa.String(length=64), nullable=False),
sa.Column('parent_id', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['parent_id'], ['category.id']),
sa.PrimaryKeyConstraint('id')
)
op.create_table(
'transaction',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('merchant', sa.String(length=128), nullable=True),
sa.Column('purchase_date', sa.DateTime(), nullable=False),
sa.Column('created', sa.DateTime(), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_table(
'split',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('note', sa.String(length=512), nullable=True),
sa.Column('transaction_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['transaction_id'], ['transaction.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table(
'association',
sa.Column('split_id', sa.Integer(), nullable=False),
sa.Column('category_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['category_id'], ['category.id'], ),
sa.ForeignKeyConstraint(['split_id'], ['split.id'], ),
sa.PrimaryKeyConstraint()
)
def downgrade():
op.drop_table('association')
op.drop_table('split')
op.drop_table('transaction')
op.drop_table('category')
| {
"repo_name": "mythmon/piper",
"path": "piper/migrations/versions/2241ef954d7f_add_initial_models.py",
"copies": "1",
"size": "1718",
"license": "mit",
"hash": 4374634549184182300,
"line_mean": 30.2363636364,
"line_max": 74,
"alpha_frac": 0.6181606519,
"autogenerated": false,
"ratio": 3.6709401709401708,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9781360374882331,
"avg_score": 0.0015480895915678523,
"num_lines": 55
} |
"""Addins are the primary way of extending FeedPlatform the add
additional aggregator functionality.
You'll find a number of them in the builtin ``feedplatform.lib``
module, although custom addins can easily be created, and
generally, when extended or specialized customization is required,
creating an addin will be a common thing to do.
Addins require an installation process to register their hooks and
other modifiers, so that addins can be loaded and reloaded at any
time. If you change the list of addins at any point afterwards,
use ``reinstall()`` to put it into effect.
It is recommended that addins subclass ``base``, though it is not
required and an addin may in fact be any object that features a
``setup`` method. Addins can also specify a tuple attribute
``depends``, referring to other addin classes that are required
for an addin to function, too. If the user hasn't specified those
addins, they will be added implicitely, so long their constructor
allows parameterless instantiation. Otherwise, an error would be
raised, asking the user to manually add the dependency.
Currently, the ``depends`` tuple may refer to the other addins only
via a class reference.
"""
import types
import inspect
from copy import copy
from feedplatform import hooks
from feedplatform import log
from feedplatform.conf import config
__all__ = ('base', 'install', 'reinstall', 'get_addins')
class base(object):
"""Common base class for addins.
It's use is optional, addins are not required to use it. However,
doing so will provide certain helpers:
* Instead of manually registering your hook callbacks, you can
simply write them as methods, using the hook name prefixed
with 'on_*' - e.g. 'on_get_guid'.
An exception will be raised if the name after 'on_' does not
refer to a valid hook.
* self.log provides a namespaced Python logging facility.
* A ``abstract`` attribute allows addins to be marked as not
directly usable.
"""
class __metaclass__(type):
def __new__(cls, name, bases, attrs):
# reset the ``abstract`` property for every new class
# automatically, i.e. does not inherit.
if not 'abstract' in attrs:
attrs['abstract'] = False
return type.__new__(cls, name, bases, attrs)
def __new__(cls, *args, **kwargs):
if getattr(cls, 'abstract', False):
raise TypeError('%s is an abstract addin.' % cls)
return super(base, cls).__new__(cls, *args, **kwargs)
def setup(self):
"""Called to have the addin register it's hook callbacks.
This is also the place for related setup jobs like setting up
custom models.
If an addin does not subclass ``addins.base``, it must provide
this method itself.
"""
# register new hook that the addin wants to define
if hasattr(self, 'get_hooks'):
new_hooks = self.get_hooks()
if hooks:
for name in new_hooks:
hooks.register(name)
# auto-register all hook callbacks ('on_*'-pattern)
for name in dir(self):
if name.startswith('on_'):
attr = getattr(self, name)
if isinstance(attr, types.MethodType):
try:
hooks.add_callback(name[3:], attr)
except KeyError, e:
raise RuntimeError(('%s: failed to initialize '
'because %s method does not refer to a valid '
'hook (%s).') % (self.__class__, name, e))
@property
def log(self):
"""Provide a logger namespace for each addin, accessible
via ``self.log``.
This is lazy, e.g. the logger is created only when accessed.
"""
if not hasattr(self, '_log'):
self._log = log.get('lib.%s' % self.__class__.__name__)
return self._log
_ADDINS = None
def get_addins():
"""Return the actual list of currently active addin instances,
as opposed to config.ADDINS, which is just the original user input.
"""
global _ADDINS
if _ADDINS is None:
reinstall()
return _ADDINS
def _make_addin(addin):
"""Normalizes addin's given by the user - makes sure an instance
is returned.
If ``addin`` is a class, an instance is created, if possible.
Otherwise, an error is raised, or ``addin`` is returned unmodified.
"""
if isinstance(addin, type):
if not addin.__init__ is object.__init__: # won't work with getargspec
args, _, _, defaults = inspect.getargspec(addin.__init__)
# for method types, the first argument will be the
# self-pointer, which we know will get filled, so we
# may ignore it.
if isinstance(addin.__init__, types.MethodType) and args:
args = args[1:]
if (not defaults and args) or (defaults and len(args) != len(defaults)):
raise ValueError('The addin "%s" was given as a class, '
'rather than an instance, but requires arguments '
'to be constructed.' % addin.__name__)
addin = addin()
return addin
def reinstall(addins=None):
"""Install the addins specified by the configuration, or via
``addins`.
The addin installation process consists mainly if letting each
adding register it's hook callbacks, as well as rebuilding the
models.
Addins that were previously installed will automatically be
removed.
The function returns the list of addins installed. It may
differ from the explicitly specified list due to dependencies,
and will contain only addin instances, not classes.
"""
if addins is None:
addins = copy(config.ADDINS)
# Start by making sure all addins are available as instances,
# and use a separate list that we may modify going further.
# Note that by starting with an initial list of all specified
# addins, dependency order is not enforced for those. E.g. if
# ``b`` depends on ``a`, but the user puts ``b`` before ``a``,
# then that will be accepted by this installation process. In
# contrast, if he only specifies ``b``, the ``a`` dependency
# would automatically be inserted before it.
to_be_setup = []
for addin in addins:
to_be_setup.append(_make_addin(addin))
# resolve dependencies
for i in range(0, len(to_be_setup)):
def resolve_dependencies(addin, index):
dependencies = getattr(addin, 'depends', ())
for dependency in dependencies:
exists = False
# Check if the dependency is already installed. Note
# that dependencies may be both classes and instances.
for existing in to_be_setup:
if not isinstance(dependency, type):
if isinstance(existing, type(dependency)):
exists = True
elif isinstance(existing, dependency):
exists = True
# if not, insert it at the right position, and
# recursively resolve it's own dependencies.
if not exists:
dependency = _make_addin(dependency)
to_be_setup.insert(index, dependency)
index = resolve_dependencies(dependency, index)
index += 1
return index
i = resolve_dependencies(to_be_setup[i], i)
# finally, setup all the addins we determined to be installed
hooks.reset()
for addin in to_be_setup:
addin.setup()
global _ADDINS
_ADDINS = to_be_setup
return to_be_setup
def install(*args, **kwargs):
"""Like ``reinstall``, but only works the very first time the
addins need to be installed. If they already are, this is a noop.
Useful if you need to ensure that addins are active.
"""
global _ADDINS
if _ADDINS is None:
return reinstall(*args, **kwargs) | {
"repo_name": "miracle2k/feedplatform",
"path": "feedplatform/addins.py",
"copies": "1",
"size": "8393",
"license": "bsd-2-clause",
"hash": 4249017373016078300,
"line_mean": 35.8153153153,
"line_max": 84,
"alpha_frac": 0.6019301799,
"autogenerated": false,
"ratio": 4.502682403433476,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5604612583333476,
"avg_score": null,
"num_lines": null
} |
"""add instance logs to db.
Revision ID: 5b9110dd4ffd
Revises: 902fbdab393a
Create Date: 2017-02-10 17:22:04.107017
"""
# revision identifiers, used by Alembic.
revision = '5b9110dd4ffd'
down_revision = '902fbdab393a'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('instance_logs',
sa.Column('id', sa.String(length=32), nullable=False),
sa.Column('instance_id', sa.String(length=32), nullable=True),
sa.Column('log_level', sa.String(length=8), nullable=True),
sa.Column('log_type', sa.String(length=64), nullable=True),
sa.Column('timestamp', sa.Float(), nullable=True),
sa.Column('message', sa.Text(), nullable=True),
sa.ForeignKeyConstraint(['instance_id'], ['instances.id'], name=op.f('fk_instance_logs_instance_id_instances')),
sa.PrimaryKeyConstraint('id', name=op.f('pk_instance_logs'))
)
op.create_index(op.f('ix_instance_logs_instance_id'), 'instance_logs', ['instance_id'], unique=False)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_instance_logs_instance_id'), table_name='instance_logs')
op.drop_table('instance_logs')
### end Alembic commands ###
| {
"repo_name": "CSC-IT-Center-for-Science/pouta-blueprints",
"path": "migrations/versions/5b9110dd4ffd_.py",
"copies": "1",
"size": "1310",
"license": "mit",
"hash": -5208705421202935000,
"line_mean": 34.4054054054,
"line_max": 116,
"alpha_frac": 0.6832061069,
"autogenerated": false,
"ratio": 3.266832917705736,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4450039024605736,
"avg_score": null,
"num_lines": null
} |
"""Addins that deal with item enclosures.
TODO: A ``store_enclosure`` addin (singular) that handles only one
enclosure and doesn't rely on a separate table, but rather fields
in the item table might be nice.
"""
import datetime
from storm.locals import Unicode, Int, Reference, ReferenceSet
from feedplatform import addins
from feedplatform import db
from feedplatform import hooks
from feedplatform.lib.addins.feeds.collect_feed_data \
import base_data_collector
__all__ = (
'store_enclosures',
'collect_enclosure_data'
)
class store_enclosures(addins.base):
"""Stores enclosures attached to items.
Uses a separate table/model for this, which you are free to use
and extend like the existing ones.
Multiple enclosures are supported. While the RSS spec is not clear
on whether multiple enclosures are allowed, the consensus seems
to be that an entry can only have one enclosure. However, some
feeds break this rule. Atom generally allows multiple enclosures.
For all those reasons, we support multiple enclosures.
See also:
http://www.reallysimplesyndication.com/2004/12/21#a221
http://www.feedparser.org/docs/uncommon-rss.html
By default, only the ``href`` value is stored, which works
similarily to an item's ``guid``. Enclosures without a ``href``
attribute are ignored. If you need other enclosure data, see
the ``collect_enclosure_data`` addin.
To make ``collect_enclosure_data`` and possibly other addin
functionality work, this addin registers additional hooks that
make it possible to customize the enclosure handling. Those work
pretty much the same way as the hooks for item processing:
* create_enclosure (item, enclosure_dict, href)
Before an Enclosure model instance is created; May return
one to override the default creation.
* new_enclosure (enclosure, enclosure_dict)
After a new enclosure has been created; can be used to
initialize it.
* found_enclosure (enclosure, enclosure_dict)
When an enclosure was determined to be already existing.
Can be used to update it.
* process_enclosure (enclosure, enclosure_dict, created)
Like ``process_item``, this combines both ``new_enclosure``
and ``found_enclosure``. While the enclosure, unlike an item,
will not have been flushed at this point, you should
nevertheless decide whether to use this hook on the same
merits: If you just want to modify the element, use
``new`` and ``found``, otherwise use ``process``. If every
addin follows this principle, ideally, during ``process``,
the enclosure object itself will not be changed, and when
combined with an addin that implicitely flushes the
enclosure, multiple writes to the enclosure are nevertheless
avoided.
"""
def get_hooks(self):
return ('create_enclosure', 'new_enclosure',
'found_enclosure', 'process_enclosure',)
def get_fields(self):
return {
'enclosure': {
'id': (Int, (), {'primary': True}),
'item_id': (Int, (), {}),
'href': (Unicode, (), {}),
'item': (Reference, ('item_id', 'Item.id',), {}),
},
'item': {
'enclosures': (ReferenceSet, ('Item.id', 'Enclosure.item_id',), {}),
}
}
def on_process_item(self, feed, item, entry_dict, item_created):
"""
Per the suggested protocol, we're using ``process_item``, since we
don't want nor need to cause an update to the item, but instead
require it to be flushed, so we can hook up enclosures to it.
"""
enclosures = entry_dict.get('enclosures', ())
# check for deleted enclosures (don't bother with new items)
if not item_created:
available_hrefs = [e.get('href') for e in enclosures]
for enclosure in item.enclosures:
if not enclosure.href in available_hrefs:
self.log.debug('Item #%d: enclosure #%d ("%s") no '
'longer exists - deleting.' % (
item.id, enclosure.id, enclosure.href))
db.store.remove(enclosure)
# add new enclosures
for enclosure_dict in enclosures:
href = enclosure_dict.get('href')
if not href:
self.log.debug('Item #%d: enclosure has no href '
'- skipping.' % item.id)
continue
try:
enclosure = db.get_one(
db.store.find(db.models.Enclosure,
db.models.Enclosure.href == href,
db.models.Enclosure.item_id == item.id))
except db.MultipleObjectsReturned:
# TODO: log a warning/error, provide a hook
# TODO: test for this case
pass
if enclosure is None:
# HOOK: CREATE_ENCLOSURE
enclosure = hooks.trigger('create_enclosure',
args=[feed, item, enclosure_dict, href])
if not enclosure:
enclosure = db.models.Enclosure()
enclosure.item = item
enclosure.href = href
db.store.add(enclosure)
# HOOK: NEW_ENCLOSURE
hooks.trigger('new_enclosure',
args=[feed, enclosure, enclosure_dict])
enclosure_created = True
self.log.debug('Item #%d: new enclosure: %s' % (item.id, href))
else:
# HOOK: FOUND_ENCLOSURE
hooks.trigger('found_enclosure',
args=[feed, enclosure, enclosure_dict])
enclosure_created = False
# HOOK: PROCESS_ENCLOSURE
hooks.trigger('process_enclosure',
args=[feed, enclosure, enclosure_dict, enclosure_created])
class collect_enclosure_data(base_data_collector):
"""Collect enclosure-level meta data, and store it in the database.
This works precisely like ``collect_feed_data``, except that
the supported known fields are:
length, type, duration
The duration is stored as an integer, in seconds. Note that this is
a special case: The duration is read from the ``itunes:duration`` tag,
which is actually item-level, since the iTunes spec doesn't support
multiple enclosures. If an item has multiple multiple enclosures, the
item's duration value will be applied to every enclosure.
Although you may specify custom fields, their use is limited, since
their rarely will be any.
"""
depends = (store_enclosures,)
model_name = 'enclosure'
standard_fields = {
'length': (Int, (), {}),
'type': (Unicode, (), {}),
'duration': (Int, (), {}),
}
def _get_value(self, source_dict, source_name, target_name, *args, **kwargs):
# length needs to be converted to an int
if source_name == 'length':
value = source_dict.get(source_name)
if not value:
return None
else:
try:
value = int(value)
if value <= 0: # negative length values make no sense
raise ValueError()
return value
except ValueError:
# TODO: potentially log an error here (in the
# yet-to-be-designed error system, not just a log message)?
self.log.debug('Enclosure has invalid length value: %s' % value)
return None
# duration needs to be read from the item level
elif source_name == 'duration':
return self.itunes_duration_value
else:
return self.USE_DEFAULT
def on_found_enclosure(self, feed, enclosure, enclosure_dict):
return self._process(enclosure, enclosure_dict)
def on_new_enclosure(self, feed, enclosure, enclosure_dict):
return self._process(enclosure, enclosure_dict)
def on_item(self, feed, data_dict, entry_dict):
# duration is read from the item, and applied on an
# enclosure-level; but only bother if it the duration
# actually requested.
if 'duration' in self.fields:
value = entry_dict.get('itunes_duration')
self.itunes_duration_value = \
self._parse_duration(value) if value else None
def _parse_duration(self, value):
try:
bits = map(int, value.split(':'))
except ValueError:
self.log.debug('Item has invalid "itunes:duration" value: %s' % value)
return None
else:
if len(bits) >= 3:
result = datetime.timedelta(hours=bits[0],
minutes=bits[1],
seconds=bits[2])
elif len(bits) == 2:
result = datetime.timedelta(minutes=bits[0],
seconds=bits[1])
elif len(bits) == 1:
result = datetime.timedelta(seconds=bits[0])
if result.days < 0: # disallow negative duration values
return None
return result.seconds | {
"repo_name": "miracle2k/feedplatform",
"path": "feedplatform/lib/addins/items/enclosures.py",
"copies": "1",
"size": "9795",
"license": "bsd-2-clause",
"hash": 509914148902111300,
"line_mean": 38.316872428,
"line_max": 84,
"alpha_frac": 0.5634507402,
"autogenerated": false,
"ratio": 4.3766756032171585,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5440126343417158,
"avg_score": null,
"num_lines": null
} |
"""Addins that handle feed images/covers.
Some of them require PIL.
# TODO: Validate against PIL addin: The image is only processed if PIL finds
a valid image, by looking at the headers (or optionally by fully reading
the image?
# TODO: Support updating the image when the href changes.
# TODO: There is an issue currently with the way the image extension is
resolved. It stems from the fact that the image extension (as returned by
``RemoteImage.extension`` may change as more data becomes available). For
example, imaging this: ``store_feed_images`` downloads and stores the main
image. At this point, the extension is read from the URL. Next,
``feed_image_thumbnails`` downloads the full image and loads it into
PIL - from now on, the PIL format will be used as the extension. Because the
original image had an incorrect extension, the original feed image will have
been saved with a different extension than the thumbnail. The same thing
happens when a .jpg extension ends up as .jpeg, because that's what PIL calls
the format (note that you may need to create at least two thumbnails to
reproduce this, since the code determines the final thumbnail file path
before downloading/loading into PIL).
When ``collect_feed_image_data`` is used to store the mage extension for
later reference, it only gets worse, because either the original or the
thumbnails will use a different extension from what is stored.
So, we probably have to do something about this. In the meantime, a user can
use a custom addin that runs before any other image addins and which ensures
that the image is loaded into PIL, therefore causing the final extension
value to be available from the beginning.
"""
import os
import datetime
import urllib2, httplib, urlparse
import cgi
import cStringIO as StringIO
from storm.locals import Unicode, DateTime
from feedplatform import addins
from feedplatform import db
from feedplatform import hooks
from feedplatform import util
from feedplatform.deps import thumbnail
from collect_feed_data import base_data_collector
__all__ = (
'handle_feed_images',
'collect_feed_image_data',
'store_feed_images',
'feed_image_restrict_frequency',
'feed_image_restrict_size',
'feed_image_restrict_extensions',
'feed_image_restrict_mediatypes',
'feed_image_thumbnails',
)
class ImageError(Exception):
"""Stop image processing.
See ``handle_feed_images`` docstring for more information on how
to use this exception in your addins.
"""
pass
class RemoteImage(object):
"""Represents a remote feed image, by wrapping around an url, and
encapsulating all access to it.
This is passed around between the various addins dealing with feed
images. It holds and provides access to related metadata, as well
as ensuring that access is as efficient as possible.
See, depending on the addins installed, and the data operated on,
we might never need to even start an HTTP request for the image.
Or, if validation fails early, we may not need to actually download
the content. Or simply reading it, without storing the information
may be enough, no need to hold it in memory.
Addins do not need to care about any of that, and what other addins
might have done already - rather, they just use the interface
exposed here.
During downloading, the ``feed_image_download_chunk`` is triggered
for each chunk read. See the ``handle_feed_images`` addin for
more information on that hook.
"""
chunk_size = 64 * 10**2
def __init__(self, url):
self.url = url
@property
def request(self):
"""Access to the HTTP request object.
The first time this is accessed, the actual request will be made.
"""
if not hasattr(self, '_request'):
try:
self._request = util.urlopen(self.url)
except util.UrlOpenError, e:
raise ImageError('failed to download: %s' % e)
return self._request
@property
def request_opened(self):
"""Return True if a HTTP request was made, and request and
response are available.
Use this if want to avoid unnecessarily opening the url, since
accessing ``request`` will do exactly that.
"""
return hasattr(self, '_request')
@property
def content_type(self):
"""Return the images mime type, as indicated by the server in
the response headers.
May be None if the data is missing.
Adapted from feedparser.py's ``_parseHTTPContentType``.
"""
content_type = self.request.headers.get('Content-Type')
if not content_type:
return None
content_type, params = cgi.parse_header(content_type)
return unicode(content_type, 'utf8', 'replace')
@property
def content_length(self):
"""Return the length of the image in bytes, as sent by the server
in the response headers.
May be None if the data is missing.
"""
length = self.request.headers.get('Content-Length')
if length:
return int(length)
return None
@property
def filename(self):
"""The filename of the image, as extracted from the URL.
Can be ``None`` if path contains no filename.
"""
parsed_url = urlparse.urlparse(self.url)
return os.path.basename(parsed_url.path) or None
# Sometimes an extension is appended to the query, for example:
# /image.php?id=345&name=200x200.png
# If that is the case, should the ``name`` completely replace
# the filename? What if "name=.png", without a filename?
## ext = parsed_url.query.rsplit('.', 1)
## ext = len(ext) >= 2 and ext[1] or ''
## if len(ext) > 4 or not ext.isalpha():
## ext = None
@property
def filename_with_ext(self):
"""The filename, but with an extension from other sources if the
url itself did not contain one.
It is however possible that under certain circumstances, no
extension can be found.
"""
filename = self.filename
if not filename:
return None
if not os.path.splitext(filename)[1]:
ext = self.extension
if ext:
filename = u'%s.%s' % (filename, ext)
return filename
@property
def extension_by_url(self):
"""Determine the file extension by looking at the URL.
If the path does not include an extension, we look at the last
part of the querystring for one.
"""
ext = os.path.splitext(self.filename or '')[1]
if ext:
return ext[1:]
@property
def extension_by_contenttype(self):
"""Determine the file extension by the content type header.
Compares against a dict of well-known content types.
"""
return {
'image/png': u'png',
'image/gif': u'gif',
'image/jpeg': u'jpg',
}.get(self.content_type, None)
@property
def extension_by_pil(self):
"""Determine the file extension by looking at the actual
image format as detected by PIL.
# TODO: Could possibly be improved so that a full image load
is not required, using ``PIL.ImageFile.Parser``, see also
``django.core.files.images.get_image_dimensions`` - having
the data available would suffice.
"""
if self.pil:
return unicode(self.pil.format.lower())
@property
def extension(self):
"""Return a file extension for the image, by trying different
things (for example, the url may not contain one).
Tries to use the most accurate method while requiring the
least amount of work. For example, the format determined by
PIL would be the definitve answer, but if the image was not
yet loaded into PIL, less precises methods are preferred.
Only if those fail will PIL be forced. (TODO: test)
Note that because of this the extension can be used if the
format of the image is needed. While there a cases when the
extension won't be a valid image format, it often is, and when
more accuracy is needed make sure the image is loaded into PIL -
in which case the PIL format will be returned as the extension.
TODO: If we don't want this behaviour after all, we could
alternatively add a new property ``format`` that basically
follows this logic: try PIL, try headers, then fall back
to ``extension``.
In an unlikely, but possible scenario, None can be returned if
no extension can be determined.
"""
if self.pil_loaded and self.extension_by_pil:
return self.extension_by_pil
if self.request_opened and self.extension_by_contenttype:
return self.extension_by_contenttype
return self.extension_by_url or \
self.extension_by_contenttype or \
self.extension_by_pil or \
None
def _load_data(self):
"""Download the image while yielding chunks as they are
coming in.
Called internally when access to the image data is needed. The
fact that the data is yielded live means the caller may already
start using it before the download is complete.
"""
# TODO: store bigger files on disk?
self._data = StringIO.StringIO()
while True:
chunk = self.request.read(self.chunk_size)
if not chunk:
break
self._data.write(chunk)
# HOOK: FEED_IMAGE_DOWNLOAD_CHUNK
if hooks.exists('feed_image_download_chunk'):
hooks.trigger('feed_image_download_chunk',
args=[self, self.data.tell()])
yield chunk
# reset once we initially loaded the data
self.data.seek(0)
@property
def data(self):
"""Access the image data as a file-object.
Will cause the image to be downloaded, and stored in a
temporary location, if not already the case.
"""
if not self.data_loaded:
for chunk in self._load_data():
pass
return self._data
@property
def data_loaded(self):
"""Return True if the image has already been downloaded.
Check this before accessing ``data` if you want to avoid
unnecessary network traffic.
"""
return hasattr(self, '_data')
def chunks(self):
"""Iterator that yields the image data in chunks.
Accessing this will cause the image to be downloaded, if that
hasn't already happend. Chunks will be yielded as they are
read.
Otherwise, it iterates over the already downloaded data.
If the image is fully available in memory, it will be
returned as a whole (a single chunk).
TODO: The idea behind yielding chunks while they are downloaded
and written to a temporary storage for future access is that the
latter might not even be necessary. Unfortunately, we currently
have no way of knowing which plugins want to access chunks(), and
how often. We could solve this maybe by letting addins "announce"
what capabilities they need (using another hook), and then we
could decide that if chunks() is only needed once, temporary
storage of the data is not even necessary.
Until that is the case, however, the "live-yielding" of chunks we
currently employ has little significance, and we could just as
well download the image fully when first needed, and then
immediately give chunks from the downloaded copy at all times.
"""
# On first access, download the image, while immediately
# yielding each chunk we read.
if not self.data_loaded:
for chunk in self._load_data():
yield chunk
# once we have the image locally, get the data from there
else:
self.data.seek(0)
while True:
# currently, _data is always a memory StringIO,
# no reason to read that in chunks
chunk = self.data.read()
if not chunk:
break
yield chunk
@property
def pil(self):
"""Return a PIL image.
Created on first access.
"""
from PIL import Image as PILImage
if not self.pil_loaded:
self.data.seek(0) # PIL lies in docs, does not rewind
try:
self._pil = PILImage.open(self.data)
# A bunch of errors are only raised when PIL actually
# attempts to decode the image, which does not necessarily
# happen when you open it. Those include for example:
# - "cannot read interlaced PNG files"
# - "* decoder not available"
# By forcing a load here we can catch them in one place,
# though at the expense of wasting performance in cases
# were a full decoding is not required (for example if
# we only need access to the format of the Image (which
# PIL "guesses" based on the header).
#
# The alternative approach would we to handle these
# exceptions manually every time an image operation is
# used that decodes the image. What we cannot do is
# catch IOError globally in handle_feed_images - there are
# other IOErrors that could occur that we don't want to
# hide, like permission problems when saving.
#
# TODO: Actually, it makes sense to do the above: Unnecessarily
# wasting resources due to loading the image when not
# required is something we should avoid. For now, we'd have
# to catch the IOError:
# - when saving the image with PIL in RemoteImage.save
# - when saving a thumbnail
# We should also add tests for both scenarios.
self._pil.load()
except IOError, e:
raise ImageError('Not a valid image: %s' % e)
return self._pil
@property
def pil_loaded(self):
"""Return True if a PIL image is already available.
Use this if want to avoid unnecessarily initializing a PIL
image, since accessing PIL will do exactly that.
"""
return hasattr(self, '_pil')
def save(self, filename, format=None):
"""Save the image to the filesystem, at the given ``filename``.
Specify ``format`` if you want to ensure a certain image format.
Note that this will force saving via PIL.
In other cases, PIL may be avoided completely.
TODO: In the future, this might support writing to an arbitrary
storage backend, rather than requiring non-filesystem addins to
write their own save() code?
"""
# If a PIL image is already available, or required due to
# a requested format conversion, save the image through PIL.
if format or (self.pil_loaded and self.pil):
self.pil.save(filename, format or self.pil.format)
# otherwise write the data manually
else:
f = open(filename, 'wb')
try:
for data in self.chunks():
f.write(data)
finally:
f.close()
class handle_feed_images(addins.base):
"""The core addin for feed image handling. All other related plugins
build on this.
It simply checks for the existance of an image, and when found,
triggers a sequence of three hooks:
* ``feed_image``:
A feed image was found; This is the initial validation stage,
and addins may return a True value to stop further processing.
For example, the file extension may be validated. An addin may
also explicitly return False to indicate that the image should
be handled while preventing the following addins from being
called.
Alternatively, you may raise an ``ImageError`` to stop
processing. The main difference, except for it automatically
being logged, is that the ``feed_image_failed`` hook is only
triggered when an exception occurs. If you problem should
result in possibly existing image records to be removed, you
want an exception.
* ``update_feed_image``:
At this point the image has been vetted, and addins may try
to process it - for example, writing it to the disk, or
submitting it to a remote storage service (i.e. S3).
If a problem occurs, you should raise an ``ImageError``,
which will stop further processing and will prevent
``feed_image_updated`` from being triggered.
* ``feed_image_updated``:
The image was successfully processed. Addins may use this
opportunity to do clean-up work, e.g. delete temporary files,
mark the success in the database, store the data necessary
to later access the image etc.
You should not raise an ``ImageError`` here, and should
generally avoid doing work that could cause problems that
could call for one.
* ``feed_image_failed``:
While processing the image an (expected) issue was
encountered. This is triggered when any of the previous hooks
results in an ``ImageError``. Note that ``feed_image``
requested a processing stop will **not** trigger this.
This basically represents the "no image available, remove
existing data" scenario. Addins should hook into this to
restore the data they manage to "no image" state.
The first three of those hooks are passed the same arguments: The
feed model instance, the image_dict from the feedparser, and a
``RemoteImage`` instance. ``feed_image_failed`` additional receives
the exception instance that caused the problem.
``RemoteImage`` is where the magic happens, since it encapsulates
all access the image for addins. For example, depending on the addins
installed, an HTTP request may or may not need sending, or the image
may or may not need downloading. See ``RemoteImage`` for more
information.
Note that the three hooks are called in direct succession, and
are therefore technically very much the same - the difference is
purely semantic. However, if you don't follow those rules there will
likely be issues when combined with other addins that do assume them
to be true.
In addition, ``RemoteImage`` itself will trigger the new
``feed_image_download_chunk`` hook for every chunk of data if
downloads. It is passed the RemoteImage instance itself, and the bytes
read so far. Currently, this functionality is used by
``feed_image_restrict_size`` to validate the file size.
"""
def get_hooks(self):
return ('feed_image', 'update_feed_image',
'feed_image_updated', 'feed_image_failed',
'feed_image_download_chunk',)
def on_after_parse(self, feed, data_dict):
# determine the image url, and bail out early if it is missing
image_href = None
image_dict = data_dict.feed.get('image')
if image_dict:
image_href = image_dict.get('href')
if not image_href:
return
image = RemoteImage(image_href)
try:
# HOOK: FEED_IMAGE
stop = hooks.trigger('feed_image', args=[feed, image_dict, image])
if stop:
return
# HOOK: UPDATE_FEED_IMAGE
hooks.trigger('update_feed_image',
args=[feed, image_dict, image],
all=True)
# HOOK: FEED_IMAGE_UPDATED
hooks.trigger('feed_image_updated',
args=[feed, image_dict, image],)
except ImageError, e:
self.log.warning('Feed #%d: error handling image "%s" (%s)' %
(feed.id, image_href, e))
# HOOK: FEED_IMAGE_FAILED
hooks.trigger('feed_image_failed',
args=[feed, image_dict, image, e],)
return
class feed_image_restrict_size(addins.base):
"""Make sure the feed image does not exceed a specific size.
``max_size`` is specified in bytes. It is checked against both
the Content-Length header (if sent), and the actual number of
bytes downloaded.
Note that the latter only happens if another addin causes the
image to be downloaded fully, whereas the former will happen
in any case, and the inclusion of this addin will cause an
HTTP request to be made.
"""
depends = (handle_feed_images,)
def __init__(self, max_size):
self.max_size = max_size
def _validate(self, size):
if size > self.max_size:
raise ImageError('image exceeds maximum size of %d' % self.max_size)
def on_feed_image(self, feed, image_dict, image):
self._validate(image.content_length)
def on_feed_image_download_chunk(self, image, bytes_read):
self._validate(bytes_read)
class feed_image_restrict_frequency(addins.base):
"""Ensures that an image is only updated every so-often.
This primarily makes sense if you download the image, and want to
avoid doing that everytime the feed is parsed, even though the image
most likely has not changed. Especially when you are doing a lot
of further processing (e.g. thumbnails), this is an addin you
probably want to use.
``delta`` is the number of seconds that must pass since the last
update of the image, before it is updated again. You may also pass
a ``timedelta`` instance.
"""
depends = (handle_feed_images,)
def __init__(self, delta):
self.delta = delta
def get_fields(self):
return {'feed': {'image_updated': (DateTime, [], {})}}
def on_feed_image(self, feed, image_dict, image):
delta = self.delta
if not isinstance(self.delta, datetime.timedelta):
delta = datetime.timedelta(seconds=self.delta)
if feed.image_updated:
if datetime.datetime.utcnow() - feed.image_updated < delta:
# stop further processing
self.log.debug('Feed #%d: image was last updated '
'recently enough' % (feed.id))
return True
def on_feed_image_updated(self, feed, image_dict, image):
feed.image_updated = datetime.datetime.utcnow()
class feed_image_restrict_extensions(addins.base):
"""Restrict feed images to specific file extension.
``allowed`` should be an iterable of extension strings, without a
dot prefix, e.g. ('png', 'gif'). If it is not specified, a default
list of extension will be used.
The extension does not necessarily need to be part of the url's
filename. The addin also tries to defer it from the content type
header, and if everything fails, the image content itself. The
latter means that the image might need to be fully downloaded
in some cases.
If an extension cannot be determined, i.e. if the image content is
invalid or in an unsupported format, it will be skipped.
"""
depends = (handle_feed_images,)
def __init__(self, allowed=None):
self.allowed = allowed
def on_feed_image(self, feed, image_dict, image):
ext = image.extension
allowed = self.allowed or ('png', 'gif', 'jpg', 'jpeg',)
if ext and (not ext in allowed):
# no (valid) image available
raise ImageError('Feed #%d: image ignored, %s is not '
'an allowed file extension' % (feed.id, ext))
class feed_image_restrict_mediatypes(addins.base):
"""Restrict feed images to specific content type headers.
``allowed`` should be an iterable of content type strings. If it
is not specified, a default list of types will be used.
If a contenet type is not available, the image is always allowed.
"""
depends = (handle_feed_images,)
def __init__(self, allowed=None):
self.allowed = allowed
def on_feed_image(self, feed, image_dict, image):
ctype = image.content_type
allowed = self.allowed or ('image/jpeg', 'image/png', 'image/gif',)
if ctype and (not ctype in allowed):
# no (valid) image available
raise ImageError('Feed #%d: image ignored, %s is not '
'an allowed content type' % (feed.id, ctype))
class store_feed_images(addins.base):
"""Will save feed images, as reported by ``handle_feed_cover``, to
the filesystem.
The required parameter ``path`` is used to specify the target
location. It should be a format string that can use the following
variables:
s model currently always "feed"
d model_id the database id of the feed
s filename the filename (``basename``) from the image url
s extension the file extension only, from the image url
For example, ``path`` might look like this:
path='/var/aggr/img/%(model)s/%(model_id)d/original.%(extension)s'
You may also pass ``path`` as a ``os.path.join``-able iterable.
Note that depending on how you store the image, you will later need
the appropriate information to access it. For example, in the example
above, the file extension is an unknown factor, and needs to be known
for access. See ``collect_feed_image_data``, which can help you with
this.
"""
depends = (handle_feed_images,)
def __init__(self, path, format=None):
self.format = format
if not isinstance(path, basestring):
self.path = os.path.join(*path)
else:
self.path = path
def _resolve_path(self, feed, image, extra=None):
vars = {
'model': feed.__class__.__name__.lower(),
'model_id': feed.id,
'filename': image.filename,
'extension': image.extension,
}
if extra:
vars.update(extra)
return self.path % vars
def _ensure_directories(self, path):
base = os.path.dirname(path)
if not os.path.exists(base):
os.makedirs(base)
def on_update_feed_image(self, feed, image_dict, image):
path = self._resolve_path(feed, image)
self._ensure_directories(path)
image.save(path, format=self.format)
class feed_image_thumbnails(store_feed_images):
"""Save thumbnail versions of feed images.
May be used instead or in combination with ``store_feed_images``.
The required argument ``sizes`` is an iterable of 2-tuples,
specifying the requested width/height values of the thumbnails.
``path`` and ``format`` work exactly like in
``store_feed_images``, but you may use these additional
format variables to specify the path:
d width
d height
s size (e.g. "200x200")
Requires PIL.
"""
def __init__(self, sizes, path, format=None):
self.sizes = sizes
super(feed_image_thumbnails, self).__init__(path, format)
def on_update_feed_image(self, feed, image_dict, image):
for size in self.sizes:
path = self._resolve_path(feed, image, {
'width': size[0],
'height': size[1],
'size': ("%dx%d" % size),
})
self._ensure_directories(path)
thumb = thumbnail.extend(image.pil, size[0], size[1])
thumb.save(path, format=self.format or image.pil.format)
class collect_feed_image_data(base_data_collector):
"""Collect feed image data and store it in the feed model.
This works precisely like the other collectors (e.g.
``collect_feed_data``), but the supported known fields are:
href, title, link, extension, filename
The model fields for each of those will be prefixed with ``image_``,
e.g. ``image_href``.
Note that ``extension`` and ``filename`` or in fact not directly
taken from the feed, but rather are preprocessed. They are intended
to support the use of addins like ``store_feed_images``.
Although you may specify custom fields, their use is limited, since
their rarely will be any.
# TODO: add a ``store_in_model`` option to use a separate model for this.
"""
depends = (handle_feed_images,)
model_name = 'feed'
standard_fields = {
'href': {'target': 'image_href', 'field': (Unicode, (), {})},
'link': {'target': 'image_link', 'field': (Unicode, (), {})},
'title': {'target': 'image_title', 'field': (Unicode, (), {})},
'extension': {'target': 'image_extension', 'field': (Unicode, (), {})},
'filename': {'target': 'image_filename', 'field': (Unicode, (), {})},
}
def _get_value(self, source_dict, source_name, target_name, image):
if source_name in ('extension', 'filename'):
if not image: # in on_feed_image_failed case
return None
if source_name == 'extension':
return image.extension
elif source_name == 'filename':
return image.filename
else:
return self.USE_DEFAULT
def on_feed_image_updated(self, feed, image_dict, image):
return self._process(feed, image_dict, image)
def on_feed_image_failed(self, feed, image_dict, image, exception):
return self._process(feed, {}, None) | {
"repo_name": "miracle2k/feedplatform",
"path": "feedplatform/lib/addins/feeds/images.py",
"copies": "1",
"size": "30912",
"license": "bsd-2-clause",
"hash": -5718747755676528000,
"line_mean": 36.8855345912,
"line_max": 80,
"alpha_frac": 0.609698499,
"autogenerated": false,
"ratio": 4.5048090935587295,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.561450759255873,
"avg_score": null,
"num_lines": null
} |
"""Addins that provide various fallbacks should a feed not provide
``<guid>`` elements to identify it's items.
Generally, it is a good idea to use many of those, since a huge number
of feeds out in the wild are in fact lacking guids, and FeedPlatform
ultimately requires *some* way to identify an item - otherwise, it
*will* be skipped.
There is, however, no perfect solution to this problem, only (better
or worse) approximations. For example, here is the strategy used by
Nick Bradbury's FeedDemon, a popular Windows feedreader:
1) Use <guid>
2) If date specified: <title> + <pubDate> (or <title> + <dc:date>)
3) If link specified: <title> + <link>
4) Use <title>
You can replicate that behaviour like so:
ADDINS += [
guid_by_content(fields=('title', 'date')),
guid_by_content(fields=('title', 'link')),
guid_by_content(fields=('title')),
]
# TODO: Not true! Nr. 1 will match even if date doesn't exist; maybe
introduce a require=(fields...) parameter syntax?
"""
from feedplatform import addins
from hashlib import md5
import calendar
__all__ = (
'guid_by_content',
'guid_by_enclosure',
'guid_by_link',
'guid_by_date',
)
class guid_by_content(addins.base):
"""Generates a guid by hashing selected item data fields.
By default, those fields are ``title`` and ``description``,
although you may use the ``fields`` option to change that
to your liking.
Note that all the fields will be used to generate the
hash - that is, if any of them changes, an item will be
considered new.
By default, the guids are prefixed with ``content:`` for
identification. You may override this using the ``prefix``
parameter, or disable it completely by passing ``False``.
By default, if all requested content fields are missing,
this addin passes (no guid is generated). You can change
that behaviour by use of ``allow_empty``.
The hash function used is md5.
"""
def __init__(self, fields=('title', 'description'), allow_empty=False,
prefix='content:'):
self.fields = fields
self.allow_empty = allow_empty
self.prefix = prefix
def on_need_guid(self, feed, item_dict):
# assemble content
content = u""
for field in self.fields:
value = item_dict.get(field)
if value:
content += unicode(value)
# return has hash
if content or self.allow_empty:
hash = md5(content.encode('ascii', 'ignore'))
result = u'%s%s' % (self.prefix or '', hash.hexdigest())
return result
return None
class guid_by_enclosure(addins.base):
"""Generates a guid based the enclosure attached to an item.
The enclosure URL will be used as the guid.
For podcast feeds, the enclosure is usually a defining element
of the item. If you are working in such a scenario, you probably
want this addin high up in your list.
Note that this only looks at the first enclosure (see the
enclosure support addin for more information on the subject of
multiple enclosures).
Attention: This requires our patched version of feedparser -
the original will always fallback to a enclosure url if a guid
is missing, which is not controllable from our side.
By default, the guids are prefixed with ``enclosure:`` for
identification. You may override this using the ``prefix``
parameter, or disable it completely by passing ``False``.
"""
def __init__(self, prefix='enclosure:'):
self.prefix = prefix
def on_need_guid(self, feed, item_dict):
enclosures = item_dict.get('enclosures')
if enclosures and len(enclosures) > 0:
enc_href = enclosures[0].get('href')
if enc_href:
return '%s%s' % (self.prefix or '', enc_href)
return None
class guid_by_link(addins.base):
"""Generates a guid based on the <link> element of an item.
The link url itself will be used as the guid. This differs from
``guid_by_content`` which could be used on the link-field with
much the same effect, but would store a hash.
This can go terribly wrong: There are a number of feeds out there
which use a common base url for all items.
By default, the guids are prefixed with ``link:`` for
identification. You may override this using the ``prefix``
parameter, or disable it completely by passing ``False``.
"""
def __init__(self, prefix='link:'):
self.prefix = prefix
def on_need_guid(self, feed, item_dict):
link = item_dict.get('link')
if link:
return '%s%s' % (self.prefix or '', link)
return None
class guid_by_date(addins.base):
"""Generates a guid based on the date of an item.
The date as a Unix timestamp will be used as the guid. A
similar effect could be achieved using ``guid_by_content``,
which would store a hash. However, what makes this one slightly
better is that if the feed starts giving dates in a different
timezone, it will still be able to identify items correctly.
The above also implies that a valid date is required, that we
are able to parse. No guids will be provided for items with
invalid dates by this addin.
By default, the guids are prefixed with ``date:`` for
identification. You may override this using the ``prefix``
parameter, or disable it completely by passing ``False``.
"""
def __init__(self, prefix='date:'):
self.prefix = prefix
def on_need_guid(self, feed, item_dict):
date_tuple = item_dict.get('date_parsed')
if date_tuple:
return u'%s%s' % (self.prefix or '',
int(calendar.timegm(date_tuple)))
return None | {
"repo_name": "miracle2k/feedplatform",
"path": "feedplatform/lib/addins/items/guid.py",
"copies": "1",
"size": "6034",
"license": "bsd-2-clause",
"hash": 5517546598208463000,
"line_mean": 32.1016949153,
"line_max": 74,
"alpha_frac": 0.6312562148,
"autogenerated": false,
"ratio": 4.113156100886163,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5244412315686162,
"avg_score": null,
"num_lines": null
} |
"""Addins that relate to HTTP functionality.
"""
from storm.locals import DateTime, Unicode
from feedplatform import addins
from feedplatform import db
from feedplatform.util import \
datetime_to_struct, struct_to_datetime, to_unicode
__all__ = (
'update_redirects',
'save_bandwith',
)
class update_redirects(addins.base):
"""Handles HTTP 301 permanent redirects.
If a server sends a permanent redirect, you should update your
database so that the new URL will be used for future requests. For
the most part, this is a straightforward job, however, with one
unfortunate catch: The new URL, the redirection target, may already
exist in your database. In which case there are a number of ways to
go on:
1) Delete the current feed
2) Delete the other feed
3) Ignore, don't change url
4) Force, change url regardless (requires the url database column
to allow duplicates)
You must choose one of the above options, and then pass to
``__init__``:
for 1) delete="self"
for 2) delete="other"
for 3) ignore=True
for 4) force=True
In any case, a log message will be emitted, which for 1-2 will be a
notice, for 3 and 4 a warning.
# TODO: add a mode for merging items
"""
def __init__(self, delete=None, force=None, ignore=None):
if delete:
if not delete in ['self', 'other']:
raise ValueError('"%s" is not a valid value for "delete". '
'Need "self" or "other".' % delete)
if not any([delete, force, ignore]):
raise ValueError('One of the parameters delete, force, '
'ignore is required')
if len([x for x in (delete, force, ignore) if x]) > 1:
raise ValueError('Only one of the parameters delete, force, '
'ignore is allowed')
if delete == 'self':
self._conflict_strategy = self._delete_self
elif delete == 'other':
self._conflict_strategy = self._delete_other
elif force:
self._conflict_strategy = self._force
elif ignore:
self._conflict_strategy = self._ignore
def on_after_parse(self, feed, data_dict):
if data_dict.status == 301:
new_url = data_dict.href
self.log.info('Feed #%d: permanent redirect to %s' % (feed.id, new_url))
dup_feeds = db.store.find(db.models.Feed, db.models.Feed.url == new_url)
if dup_feeds.any():
return self._conflict_strategy(feed, new_url, dup_feeds)
else:
feed.url = new_url
def _delete_self(self, feed, new_url, dup_feeds):
self.log.info('Redirect target already exists: removing self')
# XXX: delete related objects
db.store.remove(feed)
# don't process this feed further
return False
def _delete_other(self, feed, new_url, dup_feeds):
self.log.info('Redirect target already exists: removing the other feeds')
count = 0
for f in dup_feeds:
count += 1
# XXX: we need a solution to delete related objects as well.
# Storm doesn't seem to do it, and ON DELETE * is not
# supported by every database backend.
db.store.remove(f)
self.log.debug('%d duplicate feeds removed' % count)
feed.url = new_url
def _ignore(self, feed, new_url, dup_feeds):
# simple: don't do anything (except log), we keep the current url
self.log.info('Redirect target already exists: ignore, keeping the old url')
def _force(self, feed, new_url, dup_feeds):
self.log.info('Redirect target already exists: changing to new url anyway')
feed.url = new_url
class save_bandwith(addins.base):
"""Use the HTTP ETag and Last-Modified headers to download and parse
a feed only if the server confirms that it has indeed changed since
the last time we requested it.
You may choose to use only one of the mechanisms (etag or
last-modified) by using the ``etag`` and ``modified`` arguments to
the constructor.
Additionally, you can subclass this addin if you want to store the
http information differently. You may want to enable the
``custom_storage`` attribute of your class in this case, which will
restrain the addin from accessing the default fields. Instead, it
is then expected that you manually make sure that the ``etag`` and
``last-modified`` are stored somewhere, and you will have to
overwrite ``_get_etag`` and ``_get_modified`` to provide them when
needed.
"""
custom_storage = False
def __init__(self, etag=True, modified=True):
self.etag, self.modified = etag, modified
def get_fields(self):
if self.custom_storage:
return {}
else:
fields = {}
if self.etag:
fields.update({'http_etag': (Unicode, (), {})})
if self.modified:
fields.update({'http_modified': (DateTime, (), {})})
return {'feed': fields}
def on_before_parse(self, feed, parser_args):
if self.etag:
parser_args['etag'] = self._get_etag(feed)
if self.modified:
parser_args['modified'] = datetime_to_struct(self._get_modified(feed))
def on_after_parse(self, feed, data_dict):
if data_dict.get('status') == 304:
self.log.debug("Feed #%d: Not changed since last update ("
"status 304 returned)" % feed.id)
return True
if not self.custom_storage:
feed.http_etag = to_unicode(data_dict.get('etag'))
feed.http_modified = struct_to_datetime(data_dict.get('modified'))
def _get_etag(self, feed):
if not self.custom_storage:
return feed.http_etag
def _get_modified(self, feed):
if not self.custom_storage:
return feed.http_modified | {
"repo_name": "miracle2k/feedplatform",
"path": "feedplatform/lib/addins/feeds/http.py",
"copies": "1",
"size": "6188",
"license": "bsd-2-clause",
"hash": -6058208560989287000,
"line_mean": 34.8452380952,
"line_max": 84,
"alpha_frac": 0.5935681965,
"autogenerated": false,
"ratio": 4.21813224267212,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.531170043917212,
"avg_score": null,
"num_lines": null
} |
"""Addins that store feed metadata in the database for offline access.
# TODO: support custom rules for updating, e.g. update data never when
already existing, update always, only when a certain parser flag is
set (e.g. "fullparse"). This is useful for:
* making sure data, once set or found, can't be changed by the
feed author.
* possibly reduce database writes, if feed authors who change
their data a lot don't cause an update every time.
# TODO: option to disallow value deletion: values are only overwritten
if the new value is not empty.
"""
from datetime import datetime
from storm.locals import Unicode, DateTime
from feedplatform import addins
from feedplatform import db
from feedplatform.util import struct_to_datetime
__all__ = (
'base_data_collector',
'collect_feed_data',
)
class base_data_collector(addins.base):
"""Baseclass for data collector addins.
Subclasses should provide at least the ``model_name`` and
``standard_fields`` attributes, and may implement ``_get_value``
for additional processing.
``standard_fields`` should be a dict in the form (name => field),
with ``field`` being a database field instance or creation tuple,
and name being both the model column name and the key name to use
when reading the value from the feed parser source dict. If you
want the model field name to differ from the source field, you may
specifiy a dict for ``field``:
'href': {'target': 'image_href', 'field': (Unicode, (), {})}
See also ``collect_feed_data`` and other subclasses for information
about how these collectors can be called and used from the end-user
perspective - much of that functionality is implemented here in the
base class.
"""
abstract = True
USE_DEFAULT = object()
# provide in subclass
model_name = None
standard_fields = None
date_fields = None
# Provide special fields that every subclass supports.
class __metaclass__(type(addins.base)):
def __new__(cls, name, bases, attrs):
result = type(addins.base).__new__(cls, name, bases, attrs)
if result.standard_fields is not None:
standard_fields = result.standard_fields
result.standard_fields = {'__now': (DateTime, (), {})}
result.standard_fields.update(standard_fields)
return result
def __init__(self, *args, **kwargs):
error_msg = 'unknown standard field "%s"'
self.fields = {}
for name in args:
try:
f = self.standard_fields[name]
except KeyError:
raise ValueError(error_msg % name)
self.fields[name] = f
for key, value in kwargs.items():
if isinstance(value, basestring):
# handle std fields being stored using a different name
f = self.standard_fields.get(key)
if not f:
raise ValueError(error_msg % key)
self.fields[key] = {'target': value, 'field': f}
else:
self.fields[key] = value
# Fields may be specified as dicts or tuples: normalize
# everything to use the dict format, so we can work with a
# common datastructure from now on.
for name, value in self.fields.iteritems():
if not isinstance(value, dict):
self.fields[name] = {'field': value, 'target': name}
def get_fields(self):
return {self.model_name: dict([(k['target'], k['field'])
for n, k in self.fields.iteritems()])}
def _process(self, obj, source_dict, *args, **kwargs):
"""Call this in your respective subclass hook callback.
``args`` and ``kwargs`` will be passed along to ``_get_value``.
"""
for source_name, d in self.fields.iteritems():
target_name = d['target']
# First, let child classes handle the field, if they want.
# Otherwise, fall back to default; Do not handle default
# inside base _get_value, so that subclasses don't need to
# bother with super().
new_value = self._get_value(source_dict, source_name,
target_name, *args, **kwargs)
if new_value is self.USE_DEFAULT:
# dates need to be converted to datetime
if self.date_fields and source_name in self.date_fields:
source_name = "%s_parsed" % source_name
new_value = struct_to_datetime(source_dict.get(source_name))
else:
# Make sure to default to an empty string rather,
# than NULL, since not all schemas may allow NULL.
new_value = source_dict.get(source_name, u'')
setattr(obj, target_name, new_value)
def _get_value(self, source_dict, source_name, target_name, *args, **kwargs):
"""Overwrite this if some of your collector's fields need
additional processing.
Should return the final value, or ``self.USE_DEFAULT`` to let
default processing continue.
"""
# handle base "special" fields
if source_name == '__now':
return datetime.utcnow()
return self.USE_DEFAULT
class collect_feed_data(base_data_collector):
"""Collect feed-level meta data (as in: not item-specific), and
store it in the database.
When a feed upates it's data, so will your database.
The syntax is:
collect_feed_data(*known_fields, **custom_fields)
Known fields currently include title, subtitle, summary, link,
language, updated, modified.
Additionally, the following "special" feeds are supported:
__now - the UTC timestamp of the moment of processing
Using custom fields, you can read any field you want, but you
need to specify a datatype for the database field.
Examples:
collect_feed_data('title', 'updated')
from storm.locals import Unicode
collect_feed_data('title', prism_issn=(Unicode, (), {}))
You can also assign different columns to store the predefined default
field in:
collect_feed_data('title', updated='last_updated')
Now, the standard field ``title`` is handled normally, while
``updated`` values will be saved to a column named ``last_updated``.
If you're using custom fields, familiarize yourself with the
Feedparser normalization rules:
http://www.feedparser.org/docs/content-normalization.html
"""
model_name = 'feed'
standard_fields = {
'title': (Unicode, (), {}),
'subtitle': (Unicode, (), {}),
'summary': (Unicode, (), {}),
'link': (Unicode, (), {}),
'language': (Unicode, (), {}),
'updated': (DateTime, (), {}),
'published': (DateTime, (), {}),
}
date_fields = ('published', 'updated',)
def on_after_parse(self, feed, data_dict):
return self._process(feed, data_dict.feed)
| {
"repo_name": "miracle2k/feedplatform",
"path": "feedplatform/lib/addins/feeds/collect_feed_data.py",
"copies": "1",
"size": "7289",
"license": "bsd-2-clause",
"hash": -2916325561161206000,
"line_mean": 35.7668393782,
"line_max": 81,
"alpha_frac": 0.5947317876,
"autogenerated": false,
"ratio": 4.441803778184034,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0002119688154868939,
"num_lines": 193
} |
"""add interpreted age tables
Revision ID: 3874acf6600c
Revises: 3f5681f0fc5d
Create Date: 2015-06-19 13:46:19.937856
"""
# revision identifiers, used by Alembic.
revision = '3874acf6600c'
down_revision = '3f5681f0fc5d'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('InterpretedAgeTbl',
sa.Column('idinterpretedagetbl', sa.Integer(), nullable=False),
sa.Column('age_kind', sa.String(length=32), nullable=True),
sa.Column('kca_kind', sa.String(length=32), nullable=True),
sa.Column('age', sa.Float(), nullable=True),
sa.Column('age_err', sa.Float(), nullable=True),
sa.Column('display_age_units', sa.String(length=2), nullable=True),
sa.Column('kca', sa.Float(), nullable=True),
sa.Column('kca_err', sa.Float(), nullable=True),
sa.Column('mswd', sa.Float(), nullable=True),
sa.Column('age_error_kind', sa.String(length=80), nullable=True),
sa.Column('include_j_error_in_mean', sa.Boolean(), nullable=True),
sa.Column('include_j_error_in_plateau', sa.Boolean(), nullable=True),
sa.Column('include_j_error_in_individual_analyses', sa.Boolean(), nullable=True),
sa.PrimaryKeyConstraint('idinterpretedagetbl')
)
# op.create_table('LoadPositionTbl',
# sa.Column('idloadpositionTbl', sa.Integer(), nullable=False),
# sa.Column('identifier', sa.String(length=45), nullable=True),
# sa.Column('position', sa.Integer(), nullable=True),
# sa.Column('loadName', sa.String(length=45), nullable=True),
# sa.Column('weight', sa.Float(), nullable=True),
# sa.Column('note', sa.BLOB(), nullable=True),
# sa.ForeignKeyConstraint(['identifier'], ['IrradiationPositionTbl.identifier'], ),
# sa.ForeignKeyConstraint(['loadName'], ['LoadTbl.name'], ),
# sa.PrimaryKeyConstraint('idloadpositionTbl')
# )
# op.create_table('MeasuredPositionTbl',
# sa.Column('idmeasuredpositionTbl', sa.Integer(), nullable=False),
# sa.Column('position', sa.Integer(), nullable=True),
# sa.Column('x', sa.Float(), nullable=True),
# sa.Column('y', sa.Float(), nullable=True),
# sa.Column('z', sa.Float(), nullable=True),
# sa.Column('is_degas', sa.Boolean(), nullable=True),
# sa.Column('analysisID', sa.Integer(), nullable=True),
# sa.Column('loadName', sa.String(length=45), nullable=True),
# sa.ForeignKeyConstraint(['analysisID'], ['AnalysisTbl.idanalysisTbl'], ),
# sa.ForeignKeyConstraint(['loadName'], ['LoadTbl.name'], ),
# sa.PrimaryKeyConstraint('idmeasuredpositionTbl')
# )
op.create_table('InterpretedAgeSetTbl',
sa.Column('idinterpretedagesettbl', sa.Integer(), nullable=False),
sa.Column('interpreted_ageID', sa.Integer(), nullable=True),
sa.Column('analysisID', sa.Integer(), nullable=True),
sa.Column('forced_plateau_step', sa.Boolean(), nullable=True),
sa.Column('plateau_step', sa.Boolean(), nullable=True),
sa.Column('tag', sa.String(length=80), nullable=True),
sa.ForeignKeyConstraint(['analysisID'], ['AnalysisTbl.idanalysisTbl'], ),
sa.ForeignKeyConstraint(['interpreted_ageID'], ['InterpretedAgeTbl.idinterpretedagetbl'], ),
sa.PrimaryKeyConstraint('idinterpretedagesettbl')
)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_table('InterpretedAgeSetTbl')
# op.drop_table('MeasuredPositionTbl')
# op.drop_table('LoadPositionTbl')
op.drop_table('InterpretedAgeTbl')
### end Alembic commands ###
| {
"repo_name": "USGSDenverPychron/pychron",
"path": "alembic_dvc/versions/3874acf6600c_add_interpreted_age_.py",
"copies": "3",
"size": "3976",
"license": "apache-2.0",
"hash": -5332757514638856000,
"line_mean": 49.3291139241,
"line_max": 112,
"alpha_frac": 0.6106639839,
"autogenerated": false,
"ratio": 3.6780758556891766,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5788739839589176,
"avg_score": null,
"num_lines": null
} |
"""add interpretedtables
Revision ID: 5517015226ba
Revises: 35a07261cd96
Create Date: 2013-12-04 17:47:20.013670
"""
# revision identifiers, used by Alembic.
revision = '5517015226ba'
down_revision = '35a07261cd96'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.create_table('proc_InterpretedAgeHistoryTable',
sa.Column('id', sa.Integer, primary_key=True))
op.create_table('proc_InterpretedAgeTable',
sa.Column('id', sa.Integer, primary_key=True))
op.create_table('proc_InterpretedAgeSetTable',
sa.Column('id', sa.Integer, primary_key=True))
#op.add_column('proc_InterpretedAgeHistoryTable', sa.Column('id', sa.Integer, primary_key=True))
op.add_column('proc_InterpretedAgeHistoryTable', sa.Column('create_date', sa.TIMESTAMP,
server_default=sa.func.now()))
op.add_column('proc_InterpretedAgeHistoryTable', sa.Column('user', sa.String(80)))
op.add_column('proc_InterpretedAgeHistoryTable', sa.Column('identifier', sa.String(80)))
#op.add_column('proc_InterpretedAgeTable', sa.Column('id', sa.Integer,primary_key=True))
op.add_column('proc_InterpretedAgeTable', sa.Column('history_id', sa.Integer,
sa.ForeignKey('proc_InterpretedAgeHistoryTable.id')))
op.add_column('proc_InterpretedAgeTable', sa.Column('age_kind', sa.String(32)))
op.add_column('proc_InterpretedAgeTable', sa.Column('age', sa.Float))
op.add_column('proc_InterpretedAgeTable', sa.Column('age_err', sa.Float))
#op.add_column('proc_InterpretedAgeSetTable', sa.Column('id', sa.Integer,primary_key=True))
op.add_column('proc_InterpretedAgeSetTable', sa.Column('analysis_id', sa.Integer,
sa.ForeignKey('meas_AnalysisTable.id')))
op.add_column('proc_InterpretedAgeSetTable', sa.Column('interpreted_age_id', sa.Integer,
sa.ForeignKey('proc_InterpretedAgeTable.id')))
op.add_column('proc_InterpretedAgeSetTable', sa.Column('forced_plateau_step', sa.Boolean))
op.add_column('gen_LabTable', sa.Column('selected_interpreted_age_id',
sa.Integer, sa.ForeignKey('proc_InterpretedAgeHistoryTable.id')))
def downgrade():
op.drop_column('gen_LabTable', 'selected_interpreted_age_id')
op.drop_table('proc_InterpretedAgeSetTable')
op.drop_table('proc_InterpretedAgeTable')
op.drop_table('proc_InterpretedAgeHistoryTable')
| {
"repo_name": "USGSDenverPychron/pychron",
"path": "migration/versions/5517015226ba_add_interpretedtable.py",
"copies": "1",
"size": "2628",
"license": "apache-2.0",
"hash": -1938880660973415000,
"line_mean": 45.1052631579,
"line_max": 109,
"alpha_frac": 0.6426940639,
"autogenerated": false,
"ratio": 3.5086782376502,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9532521144281283,
"avg_score": 0.02377023145378336,
"num_lines": 57
} |
"""add invalid questionnaire flag
Revision ID: 075b9eee88b7
Revises: 9f0935df44bb
Create Date: 2018-07-18 13:07:58.598473
"""
import model.utils
import sqlalchemy as sa
from alembic import op
from rdr_service.participant_enums import QuestionnaireDefinitionStatus
# revision identifiers, used by Alembic.
revision = "075b9eee88b7"
down_revision = "9f0935df44bb"
branch_labels = None
depends_on = None
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column("questionnaire", sa.Column("status", model.utils.Enum(QuestionnaireDefinitionStatus), nullable=True))
op.add_column(
"questionnaire_history", sa.Column("status", model.utils.Enum(QuestionnaireDefinitionStatus), nullable=True)
)
# ### end Alembic commands ###
def downgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column("questionnaire_history", "status")
op.drop_column("questionnaire", "status")
# ### end Alembic commands ###
def upgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
def downgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
| {
"repo_name": "all-of-us/raw-data-repository",
"path": "rdr_service/alembic/versions/075b9eee88b7_add_invalid_questionnaire_flag.py",
"copies": "1",
"size": "1433",
"license": "bsd-3-clause",
"hash": 3348440414381786000,
"line_mean": 25.537037037,
"line_max": 119,
"alpha_frac": 0.6915561759,
"autogenerated": false,
"ratio": 3.555831265508685,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9745824446790134,
"avg_score": 0.00031259892371003487,
"num_lines": 54
} |
""" Add inventory in and inventory out link to calculate profit using FIFO method
Revision ID: a173601e2e8c
Revises: 5fa54f2ce13c
Create Date: 2017-03-29 07:06:57.758959
"""
# revision identifiers, used by Alembic.
revision = 'a173601e2e8c'
down_revision = '5fa54f2ce13c'
from alembic import op
import sqlalchemy as sa
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('inventory_in_out_link',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('date', sa.DateTime(), nullable=False),
sa.Column('product_id', sa.Integer(), nullable=False),
sa.Column('in_price', sa.Numeric(precision=8, scale=2, decimal_return_scale=2), nullable=False),
sa.Column('in_date', sa.DateTime(), nullable=False),
sa.Column('receiving_line_id', sa.Integer(), nullable=False),
sa.Column('out_price', sa.Numeric(precision=8, scale=2, decimal_return_scale=2), nullable=False),
sa.Column('out_date', sa.DateTime(), nullable=False),
sa.Column('out_quantity', sa.Numeric(precision=8, scale=2, decimal_return_scale=2), nullable=False),
sa.Column('shipping_line_id', sa.Integer(), nullable=False),
sa.Column('organization_id', sa.Integer(), nullable=True),
sa.Column('remark', sa.Text(), nullable=True),
sa.ForeignKeyConstraint(['organization_id'], ['organization.id'], ),
sa.ForeignKeyConstraint(['product_id'], ['product.id'], ),
sa.ForeignKeyConstraint(['receiving_line_id'], ['receiving_line.id'], ),
sa.ForeignKeyConstraint(['shipping_line_id'], ['shipping_line.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.add_column(u'inventory_transaction_line', sa.Column('saleable_quantity', sa.Numeric(precision=8, scale=2, decimal_return_scale=2), nullable=True))
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column(u'inventory_transaction_line', 'saleable_quantity')
op.drop_table('inventory_in_out_link')
# ### end Alembic commands ###
| {
"repo_name": "betterlife/flask-psi",
"path": "psi/migrations/versions/35_a173601e2e8c_.py",
"copies": "2",
"size": "2034",
"license": "mit",
"hash": 1548395696544570600,
"line_mean": 43.2173913043,
"line_max": 153,
"alpha_frac": 0.6902654867,
"autogenerated": false,
"ratio": 3.3619834710743803,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.505224895777438,
"avg_score": null,
"num_lines": null
} |
"""Add InventoryItem class.
Revision ID: b68e0d8ed9fe
Revises: 80e470911917
Create Date: 2017-02-03 23:19:40.082764
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'b68e0d8ed9fe'
down_revision = '80e470911917'
branch_labels = None
depends_on = None
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('user_inv_item',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('user_id', sa.BigInteger(), nullable=True),
sa.Column('item_id', sa.Integer(), autoincrement=False, nullable=False),
sa.Column('count', sa.Integer(), autoincrement=False, nullable=False),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_unique_constraint(None, 'user', ['id'])
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_constraint(None, 'user', type_='unique')
op.drop_table('user_inv_item')
# ### end Alembic commands ###
| {
"repo_name": "MJB47/Jokusoramame",
"path": "migrations/versions/b68e0d8ed9fe_add_inventoryitem_class.py",
"copies": "1",
"size": "1083",
"license": "mit",
"hash": -6716269908361171000,
"line_mean": 28.2702702703,
"line_max": 76,
"alpha_frac": 0.6712834718,
"autogenerated": false,
"ratio": 3.3220858895705523,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9478487578516099,
"avg_score": 0.0029763565708905734,
"num_lines": 37
} |
"""Add invitation related tables
Revision ID: 42bd0c8938f9
Revises: 54e63b0a9b06
Create Date: 2016-09-01 17:48:05.935684
"""
# revision identifiers, used by Alembic.
revision = '42bd0c8938f9'
down_revision = '54e63b0a9b06'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table(u'Invitation',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('unique_id', sa.Unicode(length=32), nullable=False),
sa.Column('group_id', sa.Integer(), nullable=True),
sa.Column('creation_date', sa.DateTime(), nullable=False),
sa.Column('expire_date', sa.DateTime(), nullable=True),
sa.Column('max_number', sa.Integer(), nullable=True),
sa.Column('allow_register', sa.Boolean(), nullable=False),
sa.ForeignKeyConstraint(['group_id'], [u'Group.id'], ),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('unique_id'),
mysql_engine=u'InnoDB'
)
op.create_index(u'ix_Invitation_unique_id', u'Invitation', ['unique_id'], unique=False)
op.create_table(u'AcceptedInvitation',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('invitation_id', sa.Integer(), nullable=True),
sa.Column('user_id', sa.Integer(), nullable=True),
sa.Column('accepted_date', sa.DateTime(), nullable=False),
sa.Column('registered', sa.Boolean(), nullable=False),
sa.ForeignKeyConstraint(['invitation_id'], [u'Invitation.id'], ),
sa.ForeignKeyConstraint(['user_id'], [u'User.id'], ),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('invitation_id', 'user_id'),
mysql_engine=u'InnoDB'
)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_table(u'AcceptedInvitation')
op.drop_index(u'ix_Invitation_unique_id', table_name=u'Invitation')
op.drop_table(u'Invitation')
### end Alembic commands ###
| {
"repo_name": "weblabdeusto/weblabdeusto",
"path": "server/src/weblab/db/upgrade/regular/versions/42bd0c8938f9_add_invitation_related_tables.py",
"copies": "3",
"size": "1942",
"license": "bsd-2-clause",
"hash": -3939896026292488000,
"line_mean": 35.641509434,
"line_max": 91,
"alpha_frac": 0.675592173,
"autogenerated": false,
"ratio": 3.2638655462184873,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5439457719218488,
"avg_score": null,
"num_lines": null
} |
#add IokeLexer to __all__ at the top of agile.py like so:
__all__ = ['PythonLexer', 'PythonConsoleLexer', 'PythonTracebackLexer',
'RubyLexer', 'RubyConsoleLexer', 'PerlLexer', 'LuaLexer',
'MiniDLexer', 'IoLexer', 'IokeLexer', 'TclLexer', 'ClojureLexer',
'Python3Lexer', 'Python3TracebackLexer']
#Then insert the following IokeLexer with the other class definitions:
class IokeLexer(RegexLexer):
"""
For `Ioke <http://ioke.org/>`_ (a strongly typed, dynamic,
prototype based programming language) source.
"""
name = 'Ioke'
filenames = ['*.ik']
aliases = ['ioke', 'ik']
mimetypes = ['text/x-iokesrc']
tokens = {
'interpolatableText': [
(r'(\\b|\\e|\\t|\\n|\\f|\\r|\\"|\\\\|\\#|\\\Z|\\u[0-9a-fA-F]{1,4}|\\[0-3]?[0-7]?[0-7])', String.Escape),
(r'#{', Punctuation, 'textInterpolationRoot')
],
'text': [
(r'(?<!\\)"', String, '#pop'),
include('interpolatableText'),
(r'[^"]', String)
],
'documentation': [
(r'(?<!\\)"', String.Doc, '#pop'),
include('interpolatableText'),
(r'[^"]', String.Doc)
],
'textInterpolationRoot': [
(r'}', Punctuation, '#pop'),
include('root')
],
'slashRegexp': [
(r'(?<!\\)/[oxpniums]*', String.Regex, '#pop'),
include('interpolatableText'),
(r'\\/', String.Regex),
(r'[^/]', String.Regex)
],
'squareRegexp': [
(r'(?<!\\)][oxpniums]*', String.Regex, '#pop'),
include('interpolatableText'),
(r'\\]', String.Regex),
(r'[^\]]', String.Regex)
],
'squareText': [
(r'(?<!\\)]', String, '#pop'),
include('interpolatableText'),
(r'[^\]]', String)
],
'root': [
(r'\n', Text),
(r'\s+', Text),
# Comments
(r';(.*?)\n', Comment),
(r'\A#!(.*?)\n', Comment),
#Regexps
(r'#/', String.Regex, 'slashRegexp'),
(r'#r\[', String.Regex, 'squareRegexp'),
#Symbols
(r':[a-zA-Z0-9_!:?]+', String.Symbol),
(r'[a-zA-Z0-9_!:?]+:(?![a-zA-Z0-9_!?])', String.Other),
(r':"(\\\\|\\"|[^"])*"', String.Symbol),
#Documentation
(r'((?<=fn\()|(?<=fnx\()|(?<=method\()|(?<=macro\()|(?<=lecro\()|(?<=syntax\()|(?<=dmacro\()|(?<=dlecro\()|(?<=dlecrox\()|(?<=dsyntax\())[\s\n\r]*"', String.Doc, 'documentation'),
#Text
(r'"', String, 'text'),
(r'#\[', String, 'squareText'),
#Mimic
(r'[a-zA-Z0-9_][a-zA-Z0-9!?_:]+(?=\s*=.*mimic\s)', Name.Entity),
#Assignment
(r'[a-zA-Z_][a-zA-Z0-9_!:?]*(?=[\s]*[+*/-]?=[^=].*($|\.))', Name.Variable),
# keywords
(r'(break|cond|continue|do|ensure|for|for:dict|for:set|if|let|loop|p:for|p:for:dict|p:for:set|return|unless|until|while|with)(?![a-zA-Z0-9!:_?])', Keyword.Reserved),
# Origin
(r'(eval|mimic|print|println)(?![a-zA-Z0-9!:_?])', Keyword),
# Base
(r'(cell\?|cellNames|cellOwner\?|cellOwner|cells|cell|documentation|hash|identity|mimic|removeCell\!|undefineCell\!)(?![a-zA-Z0-9!:_?])', Keyword),
# Ground
(r'(stackTraceAsText)(?![a-zA-Z0-9!:_?])', Keyword),
#DefaultBehaviour Literals
(r'(dict|list|message|set)(?![a-zA-Z0-9!:_?])', Keyword.Reserved),
#DefaultBehaviour Case
(r'(case|case:and|case:else|case:nand|case:nor|case:not|case:or|case:otherwise|case:xor)(?![a-zA-Z0-9!:_?])', Keyword.Reserved),
#DefaultBehaviour Reflection
(r'(asText|become\!|derive|freeze\!|frozen\?|in\?|is\?|kind\?|mimic\!|mimics|mimics\?|prependMimic\!|removeAllMimics\!|removeMimic\!|same\?|send|thaw\!|uniqueHexId)(?![a-zA-Z0-9!:_?])', Keyword),
#DefaultBehaviour Aspects
(r'(after|around|before)(?![a-zA-Z0-9!:_?])', Keyword.Reserved),
# DefaultBehaviour
(r'(kind|cellDescriptionDict|cellSummary|genSym|inspect|notice)(?![a-zA-Z0-9!:_?])', Keyword),
(r'(use|destructuring)', Keyword.Reserved),
#DefaultBehavior BaseBehavior
(r'(cell\?|cellOwner\?|cellOwner|cellNames|cells|cell|documentation|identity|removeCell!|undefineCell)(?![a-zA-Z0-9!:_?])', Keyword),
#DefaultBehavior Internal
(r'(internal:compositeRegexp|internal:concatenateText|internal:createDecimal|internal:createNumber|internal:createRegexp|internal:createText)(?![a-zA-Z0-9!:_?])', Keyword.Reserved),
#DefaultBehaviour Conditions
(r'(availableRestarts|bind|error\!|findRestart|handle|invokeRestart|rescue|restart|signal\!|warn\!)(?![a-zA-Z0-9!:_?])', Keyword.Reserved),
# constants
(r'(nil|false|true)(?![a-zA-Z0-9!:_?])', Name.Constant),
# names
(r'(Arity|Base|Call|Condition|DateTime|Aspects|Pointcut|Assignment|BaseBehavior|Boolean|Case|AndCombiner|Else|NAndCombiner|NOrCombiner|NotCombiner|OrCombiner|XOrCombiner|Conditions|Definitions|FlowControl|Internal|Literals|Reflection|DefaultMacro|DefaultMethod|DefaultSyntax|Dict|FileSystem|Ground|Handler|Hook|IO|IokeGround|Struct|LexicalBlock|LexicalMacro|List|Message|Method|Mixins|NativeMethod|Number|Origin|Pair|Range|Reflector|Regexp|Regexp Match|Rescue|Restart|Runtime|Sequence|Set|Symbol|System|Text|Tuple)(?![a-zA-Z0-9!:_?])', Name.Builtin),
# functions
(ur'(generateMatchMethod|aliasMethod|\u03bb|\u028E|fnx|fn|method|dmacro|dlecro|syntax|macro|dlecrox|lecrox|lecro|syntax)(?![a-zA-Z0-9!:_?])', Name.Function),
# Numbers
(r'-?0[xX][0-9a-fA-F]+', Number.Hex),
(r'-?(\d+\.?\d*|\d*\.\d+)([eE][+-]?[0-9]+)?', Number.Float),
(r'-?\d+', Number.Integer),
(r'#\(', Punctuation),
# Operators
(ur'(&&>>|\|\|>>|\*\*>>|:::|::|\.\.\.|===|\*\*>|\*\*=|&&>|&&=|\|\|>|\|\|=|\->>|\+>>|!>>|<>>>|<>>|&>>|%>>|#>>|@>>|/>>|\*>>|\?>>|\|>>|\^>>|~>>|\$>>|=>>|<<=|>>=|<=>|<\->|=~|!~|=>|\+\+|\-\-|<=|>=|==|!=|&&|\.\.|\+=|\-=|\*=|\/=|%=|&=|\^=|\|=|<\-|\+>|!>|<>|&>|%>|#>|\@>|\/>|\*>|\?>|\|>|\^>|~>|\$>|<\->|\->|<<|>>|\*\*|\?\||\?&|\|\||>|<|\*|\/|%|\+|\-|&|\^|\||=|\$|!|~|\?|#|\u2260|\u2218|\u2208|\u2209)', Operator),
(r'(and|nand|or|xor|nor|return|import)(?![a-zA-Z0-9_!?])', Operator),
# Punctuation
(r'(\`\`|\`|\'\'|\'|\.|\,|@|@@|\[|\]|\(|\)|{|})', Punctuation),
#kinds
(r'[A-Z][a-zA-Z0-9_!:?]*', Name.Class),
#default cellnames
(r'[a-z_][a-zA-Z0-9_!:?]*', Name)
]
}
| {
"repo_name": "olabini/ioke",
"path": "share/pygments/lexer.py",
"copies": "2",
"size": "6882",
"license": "mit",
"hash": -44385216918597900,
"line_mean": 42.2830188679,
"line_max": 562,
"alpha_frac": 0.4875036327,
"autogenerated": false,
"ratio": 3.010498687664042,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4498002320364041,
"avg_score": null,
"num_lines": null
} |
"""add ios available os updates fields
Revision ID: 0201b96ab856
Revises: e947cdf82307
Create Date: 2018-07-01 21:37:27.355712
"""
# From: http://alembic.zzzcomputing.com/en/latest/cookbook.html#conditional-migration-elements
from alembic import op
import sqlalchemy as sa
import commandment.dbtypes
from alembic import context
# revision identifiers, used by Alembic.
revision = '0201b96ab856'
down_revision = 'e947cdf82307'
branch_labels = None
depends_on = None
def upgrade():
schema_upgrades()
# if context.get_x_argument(as_dictionary=True).get('data', None):
# data_upgrades()
def downgrade():
# if context.get_x_argument(as_dictionary=True).get('data', None):
# data_downgrades()
schema_downgrades()
def schema_upgrades():
op.add_column('available_os_updates', sa.Column('build', sa.String(), nullable=True))
op.add_column('available_os_updates', sa.Column('download_size', sa.BigInteger(), nullable=True))
op.add_column('available_os_updates', sa.Column('install_size', sa.BigInteger(), nullable=True))
op.add_column('available_os_updates', sa.Column('product_name', sa.String(), nullable=True))
def schema_downgrades():
op.drop_column('available_os_updates', 'product_name')
op.drop_column('available_os_updates', 'install_size')
op.drop_column('available_os_updates', 'download_size')
op.drop_column('available_os_updates', 'build')
# def data_upgrades():
# """Add any optional data upgrade migrations here!"""
# pass
#
#
# def data_downgrades():
# """Add any optional data downgrade migrations here!"""
# pass
| {
"repo_name": "jessepeterson/commandment",
"path": "commandment/alembic/versions/0201b96ab856_add_ios_available_os_updates_fields.py",
"copies": "1",
"size": "1618",
"license": "mit",
"hash": -6295644024508088000,
"line_mean": 26.8965517241,
"line_max": 101,
"alpha_frac": 0.7014833127,
"autogenerated": false,
"ratio": 3.2886178861788617,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4490101198878862,
"avg_score": null,
"num_lines": null
} |
"""add ios installed application fields
Revision ID: e947cdf82307
Revises: 3061e56045eb
Create Date: 2018-07-01 20:30:53.621855
"""
# From: http://alembic.zzzcomputing.com/en/latest/cookbook.html#conditional-migration-elements
from alembic import op
import sqlalchemy as sa
import commandment.dbtypes
from alembic import context
# revision identifiers, used by Alembic.
revision = 'e947cdf82307'
down_revision = '3061e56045eb'
branch_labels = None
depends_on = None
def upgrade():
schema_upgrades()
# if context.get_x_argument(as_dictionary=True).get('data', None):
# data_upgrades()
def downgrade():
# if context.get_x_argument(as_dictionary=True).get('data', None):
# data_downgrades()
schema_downgrades()
def schema_upgrades():
op.add_column('installed_applications', sa.Column('adhoc_codesigned', sa.Boolean(), nullable=True))
op.add_column('installed_applications', sa.Column('appstore_vendable', sa.Boolean(), nullable=True))
op.add_column('installed_applications', sa.Column('beta_app', sa.Boolean(), nullable=True))
op.add_column('installed_applications', sa.Column('device_based_vpp', sa.Boolean(), nullable=True))
op.add_column('installed_applications', sa.Column('has_update_available', sa.Boolean(), nullable=True))
op.add_column('installed_applications', sa.Column('installing', sa.Boolean(), nullable=True))
op.create_index(op.f('ix_installed_applications_external_version_identifier'), 'installed_applications',
['external_version_identifier'], unique=False)
def schema_downgrades():
op.drop_index(op.f('ix_installed_applications_external_version_identifier'), table_name='installed_applications')
op.drop_column('installed_applications', 'installing')
op.drop_column('installed_applications', 'has_update_available')
op.drop_column('installed_applications', 'device_based_vpp')
op.drop_column('installed_applications', 'beta_app')
op.drop_column('installed_applications', 'appstore_vendable')
op.drop_column('installed_applications', 'adhoc_codesigned')
# def data_upgrades():
# """Add any optional data upgrade migrations here!"""
# pass
#
#
# def data_downgrades():
# """Add any optional data downgrade migrations here!"""
# pass
| {
"repo_name": "jessepeterson/commandment",
"path": "commandment/alembic/versions/e947cdf82307_add_ios_installed_application_fields.py",
"copies": "1",
"size": "2289",
"license": "mit",
"hash": 62126815360543220,
"line_mean": 34.2153846154,
"line_max": 117,
"alpha_frac": 0.7164700743,
"autogenerated": false,
"ratio": 3.5053598774885146,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9715152275611559,
"avg_score": 0.0013355352353911288,
"num_lines": 65
} |
"""add irb to questionnaire
Revision ID: 90a21cce431b
Revises: 641372364227
Create Date: 2020-10-23 13:47:03.004003
"""
from alembic import op
import sqlalchemy as sa
import rdr_service.model.utils
from rdr_service.participant_enums import PhysicalMeasurementsStatus, QuestionnaireStatus, OrderStatus
from rdr_service.participant_enums import WithdrawalStatus, WithdrawalReason, SuspensionStatus, QuestionnaireDefinitionStatus
from rdr_service.participant_enums import EnrollmentStatus, Race, SampleStatus, OrganizationType, BiobankOrderStatus
from rdr_service.participant_enums import OrderShipmentTrackingStatus, OrderShipmentStatus
from rdr_service.participant_enums import MetricSetType, MetricsKey, GenderIdentity
from rdr_service.model.base import add_table_history_table, drop_table_history_table
from rdr_service.model.code import CodeType
from rdr_service.model.site_enums import SiteStatus, EnrollingStatus, DigitalSchedulingStatus, ObsoleteStatus
# revision identifiers, used by Alembic.
revision = '90a21cce431b'
down_revision = '641372364227'
branch_labels = None
depends_on = None
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('questionnaire', sa.Column('irb_mapping', sa.String(length=500), nullable=True))
op.add_column('questionnaire', sa.Column('semantic_desc', sa.String(length=500), nullable=True))
op.add_column('questionnaire_history', sa.Column('irb_mapping', sa.String(length=500), nullable=True))
op.add_column('questionnaire_history', sa.Column('semantic_desc', sa.String(length=500), nullable=True))
# ### end Alembic commands ###
def downgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('questionnaire_history', 'semantic_desc')
op.drop_column('questionnaire_history', 'irb_mapping')
op.drop_column('questionnaire', 'semantic_desc')
op.drop_column('questionnaire', 'irb_mapping')
# ### end Alembic commands ###
def upgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
def downgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
| {
"repo_name": "all-of-us/raw-data-repository",
"path": "rdr_service/alembic/versions/90a21cce431b_add_irb_to_questionnaire.py",
"copies": "1",
"size": "2408",
"license": "bsd-3-clause",
"hash": -5936204934251027000,
"line_mean": 35.4848484848,
"line_max": 125,
"alpha_frac": 0.7446013289,
"autogenerated": false,
"ratio": 3.5153284671532847,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4759929796053285,
"avg_score": null,
"num_lines": null
} |
"""add is_creator for workspace user
Revision ID: c0394a487b8b
Revises: e8b090aa164e
Create Date: 2020-05-08 14:39:52.677433
"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import mysql
# revision identifiers, used by Alembic.
revision = 'c0394a487b8b'
down_revision = 'e8b090aa164e'
branch_labels = None
depends_on = None
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.alter_column('workbench_workspace_approved', 'name',
existing_type=mysql.VARCHAR(length=1000),
nullable=False)
op.alter_column('workbench_workspace_snapshot', 'name',
existing_type=mysql.VARCHAR(length=1000),
nullable=False)
op.add_column('workbench_workspace_user', sa.Column('is_creator', sa.Boolean(), nullable=True))
op.add_column('workbench_workspace_user_history', sa.Column('is_creator', sa.Boolean(), nullable=True))
# ### end Alembic commands ###
def downgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('workbench_workspace_user_history', 'is_creator')
op.drop_column('workbench_workspace_user', 'is_creator')
op.alter_column('workbench_workspace_snapshot', 'name',
existing_type=mysql.VARCHAR(length=1000),
nullable=True)
op.alter_column('workbench_workspace_approved', 'name',
existing_type=mysql.VARCHAR(length=1000),
nullable=True)
# ### end Alembic commands ###
def upgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
def downgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
| {
"repo_name": "all-of-us/raw-data-repository",
"path": "rdr_service/alembic/versions/c0394a487b8b_add_is_creator_for_workspace_user.py",
"copies": "1",
"size": "1950",
"license": "bsd-3-clause",
"hash": -5822099810893918000,
"line_mean": 29.46875,
"line_max": 107,
"alpha_frac": 0.6574358974,
"autogenerated": false,
"ratio": 3.672316384180791,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4829752281580791,
"avg_score": null,
"num_lines": null
} |
"""add is_deleted and last_modified columns
Revision ID: 59cbcf04663
Revises: 59935c933ab
Create Date: 2015-04-20 13:32:09.792703
"""
# revision identifiers, used by Alembic.
revision = '59cbcf04663'
down_revision = '59935c933ab'
from alembic import op
import sqlalchemy as sa
from sqlalchemy.sql import table, column
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column('title_register_data', sa.Column('is_deleted', sa.Boolean(), nullable=True))
title_register_data = table('title_register_data', column('is_deleted'))
op.execute(title_register_data.update().values(is_deleted=False))
op.alter_column('title_register_data', 'is_deleted', nullable=False)
op.add_column('title_register_data', sa.Column('last_modified',
sa.types.DateTime(timezone=True),
nullable=True))
title_register_data = table('title_register_data', column('last_modified'))
op.execute(title_register_data.update().values(last_modified=sa.func.now()))
op.alter_column('title_register_data', 'last_modified', nullable=False)
op.create_index('idx_last_modified_and_title_number', 'title_register_data',
['last_modified', 'title_number'], unique=False)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index('idx_last_modified_and_title_number', table_name='title_register_data')
op.drop_column('title_register_data', 'last_modified')
op.drop_column('title_register_data', 'is_deleted')
### end Alembic commands ###
| {
"repo_name": "LandRegistry/digital-register-api",
"path": "migrations/versions/59cbcf04663_add_is_deleted_and_last_modified_columns.py",
"copies": "1",
"size": "1681",
"license": "mit",
"hash": -3076684068678171000,
"line_mean": 39.0238095238,
"line_max": 94,
"alpha_frac": 0.6615110054,
"autogenerated": false,
"ratio": 3.6306695464362853,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.47921805518362853,
"avg_score": null,
"num_lines": null
} |
"""Add is_draft status to queries and dashboards
Revision ID: 65fc9ede4746
Revises:
Create Date: 2016-12-07 18:08:13.395586
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
from sqlalchemy.exc import ProgrammingError
revision = '65fc9ede4746'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
try:
op.add_column('queries', sa.Column('is_draft', sa.Boolean, default=True, index=True))
op.add_column('dashboards', sa.Column('is_draft', sa.Boolean, default=True, index=True))
op.execute("UPDATE queries SET is_draft = (name = 'New Query')")
op.execute("UPDATE dashboards SET is_draft = false")
except ProgrammingError as e:
# The columns might exist if you ran the old migrations.
if 'column "is_draft" of relation "queries" already exists' in e.message:
print "Can't run this migration as you already have is_draft columns, please run:"
print "./manage.py db stamp {} # you might need to alter the command to match your environment.".format(revision)
exit()
def downgrade():
op.drop_column('queries', 'is_draft')
op.drop_column('dashboards', 'is_draft')
| {
"repo_name": "EverlyWell/redash",
"path": "migrations/versions/65fc9ede4746_add_is_draft_status_to_queries_and_.py",
"copies": "9",
"size": "1229",
"license": "bsd-2-clause",
"hash": 6163682399812627000,
"line_mean": 33.1388888889,
"line_max": 125,
"alpha_frac": 0.6834825061,
"autogenerated": false,
"ratio": 3.636094674556213,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0042112644972238066,
"num_lines": 36
} |
"""Add is_draft status to queries and dashboards
Revision ID: 65fc9ede4746
Revises:
Create Date: 2016-12-07 18:08:13.395586
"""
from __future__ import print_function
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
from sqlalchemy.exc import ProgrammingError
revision = '65fc9ede4746'
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
try:
op.add_column('queries', sa.Column('is_draft', sa.Boolean, default=True, index=True))
op.add_column('dashboards', sa.Column('is_draft', sa.Boolean, default=True, index=True))
op.execute("UPDATE queries SET is_draft = (name = 'New Query')")
op.execute("UPDATE dashboards SET is_draft = false")
except ProgrammingError as e:
# The columns might exist if you ran the old migrations.
if 'column "is_draft" of relation "queries" already exists' in e.message:
print("Can't run this migration as you already have is_draft columns, please run:")
print("./manage.py db stamp {} # you might need to alter the command to match your environment.".format(revision))
exit()
def downgrade():
op.drop_column('queries', 'is_draft')
op.drop_column('dashboards', 'is_draft')
| {
"repo_name": "moritz9/redash",
"path": "migrations/versions/65fc9ede4746_add_is_draft_status_to_queries_and_.py",
"copies": "5",
"size": "1269",
"license": "bsd-2-clause",
"hash": 5992217628889519000,
"line_mean": 33.2972972973,
"line_max": 126,
"alpha_frac": 0.6847911742,
"autogenerated": false,
"ratio": 3.6570605187319885,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.004092794069966853,
"num_lines": 37
} |
"""Add is_draft status to queries and dashboards
Revision ID: 65fc9ede4746
Revises:
Create Date: 2016-12-07 18:08:13.395586
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
from sqlalchemy.exc import ProgrammingError
revision = "65fc9ede4746"
down_revision = None
branch_labels = None
depends_on = None
def upgrade():
try:
op.add_column(
"queries", sa.Column("is_draft", sa.Boolean, default=True, index=True)
)
op.add_column(
"dashboards", sa.Column("is_draft", sa.Boolean, default=True, index=True)
)
op.execute("UPDATE queries SET is_draft = (name = 'New Query')")
op.execute("UPDATE dashboards SET is_draft = false")
except ProgrammingError as e:
# The columns might exist if you ran the old migrations.
if 'column "is_draft" of relation "queries" already exists' in str(e):
print(
"Can't run this migration as you already have is_draft columns, please run:"
)
print(
"./manage.py db stamp {} # you might need to alter the command to match your environment.".format(
revision
)
)
exit()
def downgrade():
op.drop_column("queries", "is_draft")
op.drop_column("dashboards", "is_draft")
| {
"repo_name": "denisov-vlad/redash",
"path": "migrations/versions/65fc9ede4746_add_is_draft_status_to_queries_and_.py",
"copies": "3",
"size": "1370",
"license": "bsd-2-clause",
"hash": -20671171271675856,
"line_mean": 28.1489361702,
"line_max": 114,
"alpha_frac": 0.6102189781,
"autogenerated": false,
"ratio": 3.848314606741573,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0009175412785911612,
"num_lines": 47
} |
"""Add is_ready field to Project.
Revision ID: 2aa8c8ea9d62
Revises: 4f99b161d06c
Create Date: 2013-02-13 11:22:37.123917
"""
# revision identifiers, used by Alembic.
revision = '2aa8c8ea9d62'
down_revision = '4f99b161d06c'
from alembic import op
import sqlalchemy as sa
from sqlalchemy.schema import DefaultClause
from sqlalchemy.dialects import postgresql
project = sa.sql.table('project', sa.Column('is_ready', sa.Boolean(),
nullable=True))
def upgrade():
# Add is ready
op.add_column('project', sa.Column('is_ready', sa.Boolean(),
nullable=True))
op.execute(project.update().values(is_ready=True))
# Update nullability
op.alter_column(u'project', u'is_ready', existing_type=sa.Boolean(),
nullable=False)
op.alter_column(u'testcaseresult', u'status',
existing_type=postgresql.ENUM(u'nonexistent_executable', u'output_limit_exceeded', u'signal', u'success', u'timed_out', name=u'status'),
nullable=False)
def downgrade():
# Remove column
op.drop_column('project', 'is_ready')
# Revert nullability of testcaseresult
op.alter_column(u'testcaseresult', u'status',
existing_type=postgresql.ENUM(u'nonexistent_executable', u'output_limit_exceeded', u'signal', u'success', u'timed_out', name=u'status'),
nullable=True)
| {
"repo_name": "ucsb-cs/submit",
"path": "submit/migrations/versions/2aa8c8ea9d62_add_is_ready_field_t.py",
"copies": "1",
"size": "1428",
"license": "bsd-2-clause",
"hash": -4777260176930122000,
"line_mean": 33,
"line_max": 151,
"alpha_frac": 0.6470588235,
"autogenerated": false,
"ratio": 3.457627118644068,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4604685942144068,
"avg_score": null,
"num_lines": null
} |
"""add is_reviewed to workspace table
Revision ID: 679d13d850ce
Revises: 1edcfe7d61ec
Create Date: 2020-04-29 12:53:17.135885
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '679d13d850ce'
down_revision = '1edcfe7d61ec'
branch_labels = None
depends_on = None
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('workbench_workspace_approved', sa.Column('is_reviewed', sa.Boolean(), nullable=True))
op.add_column('workbench_workspace_snapshot', sa.Column('is_reviewed', sa.Boolean(), nullable=True))
# ### end Alembic commands ###
def downgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('workbench_workspace_snapshot', 'is_reviewed')
op.drop_column('workbench_workspace_approved', 'is_reviewed')
# ### end Alembic commands ###
def upgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
def downgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
| {
"repo_name": "all-of-us/raw-data-repository",
"path": "rdr_service/alembic/versions/679d13d850ce_add_is_reviewed_to_workspace_table.py",
"copies": "1",
"size": "1327",
"license": "bsd-3-clause",
"hash": -394644042766869200,
"line_mean": 25.0196078431,
"line_max": 104,
"alpha_frac": 0.6767143934,
"autogenerated": false,
"ratio": 3.473821989528796,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4650536382928796,
"avg_score": null,
"num_lines": null
} |
"""Add is_test_sample flag to biobank_dv_order
Revision ID: 39f421efaa73
Revises: 9cbaee181bc9
Create Date: 2020-03-17 12:13:52.824158
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '39f421efaa73'
down_revision = '9cbaee181bc9'
branch_labels = None
depends_on = None
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('biobank_dv_order', sa.Column('is_test_sample', sa.Boolean(), nullable=True))
# ### end Alembic commands ###
def downgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('biobank_dv_order', 'is_test_sample')
# ### end Alembic commands ###
def upgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
def downgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
| {
"repo_name": "all-of-us/raw-data-repository",
"path": "rdr_service/alembic/versions/39f421efaa73_add_is_test_sample_flag_to_biobank_dv_.py",
"copies": "1",
"size": "1146",
"license": "bsd-3-clause",
"hash": 3025442355486442000,
"line_mean": 22.875,
"line_max": 95,
"alpha_frac": 0.6631762653,
"autogenerated": false,
"ratio": 3.4107142857142856,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9468638814903174,
"avg_score": 0.021050347222222224,
"num_lines": 48
} |
"""add is_utc_to_pages
Revision ID: 16dbded8a5cf
Revises: a0f4fda7588f
Create Date: 2016-12-14 23:46:54.211173
"""
# revision identifiers, used by Alembic.
revision = '16dbded8a5cf'
down_revision = 'a0f4fda7588f'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_development():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('front_pages', sa.Column('is_utc', sa.Boolean(), nullable=True))
op.add_column('subreddit_pages', sa.Column('is_utc', sa.Boolean(), nullable=True))
# ### end Alembic commands ###
def downgrade_development():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('subreddit_pages', 'is_utc')
op.drop_column('front_pages', 'is_utc')
# ### end Alembic commands ###
def upgrade_test():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('front_pages', sa.Column('is_utc', sa.Boolean(), nullable=True))
op.add_column('subreddit_pages', sa.Column('is_utc', sa.Boolean(), nullable=True))
# ### end Alembic commands ###
def downgrade_test():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('subreddit_pages', 'is_utc')
op.drop_column('front_pages', 'is_utc')
# ### end Alembic commands ###
def upgrade_production():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('front_pages', sa.Column('is_utc', sa.Boolean(), nullable=True))
op.add_column('subreddit_pages', sa.Column('is_utc', sa.Boolean(), nullable=True))
# ### end Alembic commands ###
def downgrade_production():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('subreddit_pages', 'is_utc')
op.drop_column('front_pages', 'is_utc')
# ### end Alembic commands ###
| {
"repo_name": "c4fcm/CivilServant",
"path": "alembic/versions/16dbded8a5cf_add_is_utc_to_pages.py",
"copies": "1",
"size": "2009",
"license": "mit",
"hash": 5533098550293813000,
"line_mean": 28.5441176471,
"line_max": 86,
"alpha_frac": 0.6550522648,
"autogenerated": false,
"ratio": 3.348333333333333,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4503385598133333,
"avg_score": null,
"num_lines": null
} |
"""Add ItemSequence
Revision ID: 1f5caa34d9c2
Revises: bb141e41aab
Create Date: 2014-03-31 22:44:32.721446
"""
# revision identifiers, used by Alembic.
revision = '1f5caa34d9c2'
down_revision = 'bb141e41aab'
from alembic import op
import sqlalchemy as sa
NEXT_ITEM_VALUE_FUNCTION = """
CREATE OR REPLACE FUNCTION next_item_value(uuid) RETURNS int AS $$
DECLARE
cur_parent_id ALIAS FOR $1;
next_value int;
BEGIN
LOOP
UPDATE itemsequence SET value = value + 1 WHERE parent_id = cur_parent_id
RETURNING value INTO next_value;
IF FOUND THEN
RETURN next_value;
END IF;
BEGIN
INSERT INTO itemsequence (parent_id, value) VALUES (cur_parent_id, 1)
RETURNING value INTO next_value;
RETURN next_value;
EXCEPTION WHEN unique_violation THEN
-- do nothing
END;
END LOOP;
END;
$$ LANGUAGE plpgsql
"""
ADD_BUILD_SEQUENCES = """
INSERT INTO itemsequence (parent_id, value)
SELECT project_id, max(number) FROM build GROUP BY project_id
"""
ADD_JOB_SEQUENCES = """
INSERT INTO itemsequence (parent_id, value)
SELECT build_id, count(*) FROM job WHERE build_id IS NOT NULL GROUP BY build_id
"""
def upgrade():
op.create_table('itemsequence',
sa.Column('parent_id', sa.GUID(), nullable=False),
sa.Column('value', sa.Integer(), server_default='1', nullable=False),
sa.PrimaryKeyConstraint('parent_id', 'value')
)
op.execute(NEXT_ITEM_VALUE_FUNCTION)
op.execute(ADD_BUILD_SEQUENCES)
op.execute(ADD_JOB_SEQUENCES)
def downgrade():
op.drop_table('itemsequence')
op.execute('DROP FUNCTION IF EXISTS next_item_value(uuid)')
| {
"repo_name": "dropbox/changes",
"path": "migrations/versions/1f5caa34d9c2_add_itemsequence.py",
"copies": "4",
"size": "1636",
"license": "apache-2.0",
"hash": 6586986604427308000,
"line_mean": 23.7878787879,
"line_max": 79,
"alpha_frac": 0.6900977995,
"autogenerated": false,
"ratio": 3.23960396039604,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.592970175989604,
"avg_score": null,
"num_lines": null
} |
"""Additional autograd differential operators."""
from functools import wraps
AUTOGRAD_AVAILABLE = True
try:
from autograd import make_vjp as vjp_and_value
from autograd.wrap_util import unary_to_nary
from autograd.builtins import tuple as atuple
from autograd.core import make_vjp
from autograd.extend import vspace
import autograd.numpy as np
except ImportError:
AUTOGRAD_AVAILABLE = False
def _wrapped_unary_to_nary(func):
"""Use functools.wraps with unary_to_nary decorator."""
if AUTOGRAD_AVAILABLE:
return wraps(func)(unary_to_nary(func))
else:
return func
@_wrapped_unary_to_nary
def grad_and_value(fun, x):
"""
Makes a function that returns both gradient and value of a function.
"""
vjp, val = make_vjp(fun, x)
if not vspace(val).size == 1:
raise TypeError(
"grad_and_value only applies to real scalar-output" " functions."
)
return vjp(vspace(val).ones()), val
@_wrapped_unary_to_nary
def jacobian_and_value(fun, x):
"""
Makes a function that returns both the Jacobian and value of a function.
Assumes that the function `fun` broadcasts along the first dimension of the
input being differentiated with respect to such that a batch of outputs can
be computed concurrently for a batch of inputs.
"""
val = fun(x)
v_vspace = vspace(val)
x_vspace = vspace(x)
x_rep = np.tile(x, (v_vspace.size,) + (1,) * x_vspace.ndim)
vjp_rep, _ = make_vjp(fun, x_rep)
jacobian_shape = v_vspace.shape + x_vspace.shape
basis_vectors = np.array([b for b in v_vspace.standard_basis()])
jacobian = vjp_rep(basis_vectors)
return np.reshape(jacobian, jacobian_shape), val
@_wrapped_unary_to_nary
def mhp_jacobian_and_value(fun, x):
"""
Makes a function that returns MHP, Jacobian and value of a function.
For a vector-valued function `fun` the matrix-Hessian-product (MHP) is here
defined as a function of a matrix `m` corresponding to
mhp(m) = sum(m[:, :, None] * h[:, :, :], axis=(0, 1))
where `h` is the vector-Hessian of `f = fun(x)` wrt `x` i.e. the rank-3
tensor of second-order partial derivatives of the vector-valued function,
such that
h[i, j, k] = ∂²f[i] / (∂x[j] ∂x[k])
Assumes that the function `fun` broadcasts along the first dimension of the
input being differentiated with respect to such that a batch of outputs can
be computed concurrently for a batch of inputs.
"""
mhp, (jacob, val) = make_vjp(lambda x: atuple(jacobian_and_value(fun)(x)), x)
return lambda m: mhp((m, vspace(val).zeros())), jacob, val
@_wrapped_unary_to_nary
def hessian_grad_and_value(fun, x):
"""
Makes a function that returns the Hessian, gradient & value of a function.
Assumes that the function `fun` broadcasts along the first dimension of the
input being differentiated with respect to such that a batch of outputs can
be computed concurrently for a batch of inputs.
"""
def grad_fun(x):
vjp, val = make_vjp(fun, x)
return vjp(vspace(val).ones()), val
x_vspace = vspace(x)
x_rep = np.tile(x, (x_vspace.size,) + (1,) * x_vspace.ndim)
vjp_grad, (grad, val) = make_vjp(lambda x: atuple(grad_fun(x)), x_rep)
hessian_shape = x_vspace.shape + x_vspace.shape
basis_vectors = np.array([b for b in x_vspace.standard_basis()])
hessian = vjp_grad((basis_vectors, vspace(val).zeros()))
return np.reshape(hessian, hessian_shape), grad[0], val[0]
@_wrapped_unary_to_nary
def mtp_hessian_grad_and_value(fun, x):
"""
Makes a function that returns MTP, Jacobian and value of a function.
For a scalar-valued function `fun` the matrix-Tressian-product (MTP) is
here defined as a function of a matrix `m` corresponding to
mtp(m) = sum(m[:, :] * t[:, :, :], axis=(-1, -2))
where `t` is the 'Tressian' of `f = fun(x)` wrt `x` i.e. the 3D array of
third-order partial derivatives of the scalar-valued function such that
t[i, j, k] = ∂³f / (∂x[i] ∂x[j] ∂x[k])
Assumes that the function `fun` broadcasts along the first dimension of the
input being differentiated with respect to such that a batch of outputs can
be computed concurrently for a batch of inputs.
"""
mtp, (hessian, grad, val) = make_vjp(
lambda x: atuple(hessian_grad_and_value(fun)(x)), x
)
return (
lambda m: mtp((m, vspace(grad).zeros(), vspace(val).zeros())),
hessian,
grad,
val,
)
| {
"repo_name": "matt-graham/hmc",
"path": "mici/autograd_wrapper.py",
"copies": "1",
"size": "4569",
"license": "mit",
"hash": -6592566817244653000,
"line_mean": 33.4924242424,
"line_max": 81,
"alpha_frac": 0.6531956951,
"autogenerated": false,
"ratio": 3.2684852835606604,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.44216809786606603,
"avg_score": null,
"num_lines": null
} |
"""Additional behaviors for genetic algorithms.
Contents
--------
:FittestTriggerGA:
A GA that triggers an event whenever a new best fitness score is observed.
:FittestInGenerationGA:
A GA that stores the fittest chromosome from each generation and its score.
:FinishWhenSlowGA:
A GA that will terminate when it is no longer making progress.
Note that when using strategies that do not score each member of every
generation, such as tournament selection, best scores may go undetected.
Also note that, if using such a strategy, it is possible that adding logging
will create the side effect of squelching this behavior, since some logging
strategies score all chromosomes.
"""
from __future__ import division
import math
from . import GeneticAlgorithm
class FittestTriggerGA(GeneticAlgorithm):
"""A GA with an event for new high scores.
When a new all-time high score is observed for this instance, the
``new_best`` method is invoked.
"""
def __init__(self, config={}):
super(FittestTriggerGA, self).__init__(config)
self.best_score = (0, None)
def fitness(self, chromosome):
"""Check the score of a chromosome.
Triggers ``new_best`` if there's a winner.
"""
score = super(FittestTriggerGA, self).fitness(chromosome)
if score > self.best_score[0]:
self.new_best(score, chromosome)
self.best_score = (score, chromosome)
return score
def new_best(self, score, chromosome):
"""Triggered when a new best fitness score is seen."""
pass
def best(self):
return self.best_score[1]
class FittestInGenerationGA(FittestTriggerGA):
"""A behavior that stores the best score from each generation.
The fittest chromosome and its score of each generation are stored as a
2-tuple of ``(score, chromosome)`` in ``self.best_scores``.
"""
def __init__(self, config={}):
super(FittestInGenerationGA, self).__init__(config)
self.best_scores = []
def pre_generate(self):
super(FittestInGenerationGA, self).pre_generate()
self.best_score = (0, None)
def post_generate(self):
super(FittestInGenerationGA, self).post_generate()
self.best_scores.append(self.best_score[0])
class FinishWhenSlowGA(FittestInGenerationGA):
"""A GA that will terminate when it is no longer making progress.
To configure this behavior, adjust the ``threshold`` and ``lookback``
configuration properties.
If the percentage improvement of progress in ``lookback`` iterations hasn't
exceeded ``threshold``, then the GA will terminate. The GA will also
terminate if the number of iterations has exceeded ``max_iterations``.
"""
def __init__(self, config={}):
super(FinishWhenSlowGA, self).__init__(config)
self.threshold = self.config.setdefault("threshold", 0.05)
self.lookback = self.config.setdefault("lookback", 5)
def is_finished(self):
exceeded_duration = self.iteration >= self.max_iterations
if len(self.best_scores) > self.lookback:
first = self.best_scores[-self.lookback]
last = self.best_scores[-1]
gain = (last - first) / first
return gain <= self.threshold or exceeded_duration
else:
return exceeded_duration
| {
"repo_name": "rawg/levis",
"path": "levis/behavior.py",
"copies": "1",
"size": "3378",
"license": "mit",
"hash": -7987479584750882000,
"line_mean": 30.5700934579,
"line_max": 79,
"alpha_frac": 0.6705150977,
"autogenerated": false,
"ratio": 4.0262216924910605,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.519673679019106,
"avg_score": null,
"num_lines": null
} |
"""Additional clustering algorithms and estimators."""
import numpy as np
from scipy.cluster.hierarchy import fcluster
from scipy.cluster.hierarchy import linkage
from sklearn.base import BaseEstimator
from sklearn.base import ClusterMixin
from sklearn.utils import check_array
def hierarchical_clustering(
X,
max_dist=0.5,
method='single',
metric='euclidean',
criterion='inconsistent',
):
"""Performs hierarchical/agglomerative clustering on the input
array.
Parameters
----------
max_dist : float (default=0.5)
Maximum allowed distance for two clusters to be merged.
method : str (default='single')
How distances are applied, see scipy.cluster.hierarchy.linkage
documentation.
metric : str (default='euclidean')
Which distance metric to use. See
scipy.cluster.hierarchy.linkage documentation.
criterion : str (default='inconsistent')
Criterion to use in forming flat clusters. See
scipy.cluster.hierarchy.fcluster documentation.
"""
# pylint: disable=len-as-condition
if len(X) < 1:
return np.array([])
if len(X) == 1:
return np.array([0])
labels = fcluster(
linkage(
X,
method=method,
metric=metric,
),
t=max_dist,
criterion=criterion,
)
return labels
class HierarchicalClustering(BaseEstimator, ClusterMixin):
"""Use hierarchical clustering with cut-off value.
Similar to sklearn.cluster.hierarchical.linkage_tree but does not
require to indicate the number of clusters beforehand. Instead,
the number of clusters is determined dynamically by use of the
cut-off value `max_dist`. Therefore, the number of different
clusters will depend on the input data, similarly to DBSCAN.
Note: `HierarchicalClustering` does not support sparse
matrices. If you want to use sparse matrices, pre-compute the
pair-wise distance matrix (e.g. with
`scipy.spatial.distance.pdist`), transform it using
`scipy.spatial.distance.squareform`, and pass the result to this
estimator with parameter `metric` set to None.
Parameters
----------
max_dist : float (default=0.5)
Maximum allowed distance for two clusters to be merged.
method : str (default='single')
How distances are applied, see scipy.cluster.hierarchy.linkage
documentation.
metric : str (default='euclidean')
Which distance metric to use. See
scipy.cluster.hierarchy.linkage documentation.
criterion : str (default='inconsistent')
Criterion to use in forming flat clusters. See
scipy.cluster.hierarchy.fcluster documentation.
Attributes
----------
labels_ : array [n_samples]
cluster labels for each point
"""
def __init__(
self,
max_dist=0.5,
method='single',
metric='euclidean',
criterion='inconsistent',
):
self.max_dist = max_dist
self.method = method
self.metric = metric
self.criterion = criterion
# pylint: disable=attribute-defined-outside-init,unused-argument
def fit(self, X, y=None, **fit_params):
"""Fit the hierarchical clustering on the data.
Parameters
----------
X : array-like, shape = [n_samples, n_features]
The samples a.k.a. observations.
Returns
-------
self : instance of HierarchicalClustering
"""
X = check_array(X, ensure_min_samples=2, estimator=self)
self.labels_ = hierarchical_clustering(
X,
max_dist=self.max_dist,
method=self.method,
metric=self.metric,
criterion=self.criterion,
)
return self
| {
"repo_name": "ottogroup/dstoolbox",
"path": "dstoolbox/cluster.py",
"copies": "1",
"size": "3828",
"license": "apache-2.0",
"hash": 3137737069875822600,
"line_mean": 28.4461538462,
"line_max": 69,
"alpha_frac": 0.6384535005,
"autogenerated": false,
"ratio": 4.498237367802585,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5636690868302585,
"avg_score": null,
"num_lines": null
} |
"""Additional data encoders."""
from __future__ import absolute_import
from .errors import EncodingError
from collections import OrderedDict
import six
class BaseEncoder(object):
"""Base encoder class."""
def __init__(self, document):
"""Create an encoder for the given document."""
self.document = document
def is_array_value(self, value):
"""Return True if the value can be encoded to an array."""
return isinstance(value, (list, tuple, set))
def is_array_field(self, field):
"""Return True if a field stores an array."""
typ = getattr(field, 'typ', None)
return typ and hasattr(typ, 'encode_element')
def encode_default(self, name, value):
"""Return a value with default encoding."""
return value
def encode_builtin(self, builtin, name, value):
try:
return builtin(value)
except (TypeError, ValueError):
msg = "unable to encode {} value".format(builtin.__name__)
raise EncodingError(msg, self.document, name, value)
def encode_int(self, name, value):
"""Return a value encoded as an integer."""
return self.encode_builtin(int, name, value)
def encode_float(self, name, value):
"""Return a value encoded as a float."""
return self.encode_builtin(float, name, value)
def encode_bool(self, name, value):
"""Return a value encoded as a boolean."""
return self.encode_builtin(bool, name, value)
def encode_str(self, name, value):
"""Return a value encoded as a string."""
return self.encode_builtin(str, name, value)
def encode_geojson_coords(self, name, value):
"""Return a value encoded as GeoJSON coordinates."""
if not self.is_array_value(value):
return self.encode_float(name, value)
encoded = []
for item in value:
encoded.append(self.encode_geojson_coords(name, item))
return encoded
def encode_geojson(self, name, value):
"""Return a value encoded as a GeoJSON value."""
try:
value = OrderedDict(value)
except (TypeError, ValueError):
msg = "unable to encode value as GeoJSON"
raise EncodingError(msg, self.document, name, value)
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
if item_name == 'type':
item_value = self.encode_str(item_name, item_value)
elif item_name == 'coordinates':
item_value = self.encode_geojson_coords(item_name, item_value)
else:
item_value = self.encode_default(item_name, item_value)
encoded[item_name] = item_value
return encoded
class OperatorEncoder(BaseEncoder):
"""Base encoder for specs with operators."""
ops = {}
def get_encode_method(self, op):
"""Return the encode method for an operator."""
name = self.ops.get(op)
if name:
name = 'encode_' + name
if hasattr(self, name):
return getattr(self, name)
return self.encode_default
def get_field(self, name):
"""Return the field for the given name."""
return self.document._meta.get_field(name)
class SortEncoder(BaseEncoder):
"""Encode sort specs."""
def encode(self, value):
"""
Encode a sort value. Value must be convertible to an int or OrderedDict or raises an
EncodingError.
"""
if value is None:
return None
try:
value = OrderedDict(value)
encoded = OrderedDict()
for field, direction in six.iteritems(value):
direction = self.encode_int(field, direction)
field = self.encode_str(field, field)
encoded[field] = direction
return list(encoded.items())
except (TypeError, ValueError):
pass
try:
return int(value)
except (TypeError, ValueError):
pass
raise EncodingError('unable to encode sort value', value=value)
class QueryEncoder(OperatorEncoder):
"""Encode query specs."""
ops = {
'$gt': 'field',
'$gte': 'field',
'$lt': 'field',
'$lte': 'field',
'$ne': 'field',
'$in': 'field',
'$nin': 'field',
'$or': 'logical',
'$and': 'logical',
'$not': 'negation',
'$nor': 'logical',
'$exists': 'bool',
'$type': 'int',
'$mod': 'mod',
'$regex': 'str',
'$options': 'str',
'$search': 'str',
'$language': 'str',
'$where': 'str',
'$all': 'field',
'$elemMatch': 'array_query',
'$size': 'int',
'$geoWithin': 'geo',
'$geoIntersects': 'geo',
'$near': 'geo',
'$nearSphere': 'geo',
}
def __init__(self, document):
"""Create a query encoder for a document type."""
self.document = document
def is_operator_name(self, name):
"""Return True if the name is an operator name."""
return str(name)[:1] == '$'
def is_operator_value(self, value):
"""Return True if a value contains operators."""
try:
value = OrderedDict(value)
for name in value.keys():
if self.is_operator_name(name):
return True
except (TypeError, ValueError):
pass
return False
def is_compiled_regex(self, value):
"""Return True if a value is a compiled regular expression."""
return hasattr(value, 'pattern')
def encode_logical(self, name, value):
"""Return a value encoded for a logical operator."""
if not self.is_array_value(value):
raise EncodingError("unable to encode logical operator", field=name, value=value)
return [self.encode(v) for v in value]
def encode_negation(self, name, value):
"""Return a value encoded for negation."""
return self.encode(value)
def encode_mod(self, name, value):
"""Return a value encoded for modulus division."""
if not self.is_array_value(value):
raise EncodingError("unable to encode mod operator", field=name, value=value)
return [self.encode_float(name, v) for v in value]
def encode_array_query(self, name, value):
"""Return a value encoded as an array."""
from .types import DocumentType
field = self.get_field(name)
if field and self.is_array_field(field) and isinstance(field.typ.typ, DocumentType):
document = field.typ.typ.document
else:
from .document import Document
document = Document
return QueryEncoder(document).encode(value)
def encode_geo(self, name, value):
"""Return a value encoded as a geo query."""
try:
value = OrderedDict(value)
except (TypeError, ValueError):
raise EncodingError("unable to encode geo query", self.document, name, value)
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
if item_name == '$geometry':
item_value = self.encode_geojson(item_name, item_value)
elif item_name == '$maxDistance':
item_value = self.encode_int(item_name, item_value)
else:
item_value = self.encode_default(item_name, item_value)
encoded[item_name] = item_value
return encoded
def encode_field(self, name, value):
"""Return a value encoded as a field value."""
if value is None:
return None
if self.is_compiled_regex(value):
return self.encode_default(name, value)
field = self.get_field(name)
if field:
if self.is_array_value(value):
if self.is_array_field(field):
value = field.encode(self.document, name, value)
else:
value = [field.encode(self.document, name, v) for v in value]
else:
if self.is_array_field(field):
value = field.typ.encode_element(self.document, name, value)
else:
value = field.encode(self.document, name, value)
else:
value = self.encode_default(name, value)
return value
def encode_operator(self, name, value):
"""Return a value encoded as an operator dictionary."""
if value is None:
return None
encode_method = self.get_encode_method(name)
return encode_method(name, value)
def encode_operators(self, name, value):
"""Return a value encoded as an operator dictionary."""
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
item_name = self.encode_str(name, item_name)
if item_value is not None:
encode_method = self.get_encode_method(item_name)
item_value = encode_method(name, item_value)
encoded[item_name] = item_value
return encoded
def encode(self, value):
"""Return an encoded query value."""
if not value:
return None
try:
value = OrderedDict(value)
except (TypeError, ValueError):
raise EncodingError("unable to encode query", self.document, '<query>', value)
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
item_name = self.encode_str('<query>', item_name)
if self.is_operator_name(item_name):
item_value = self.encode_operator(item_name, item_value)
if self.is_operator_value(item_value):
item_value = self.encode_operators(item_name, item_value)
else:
item_value = self.encode_field(item_name, item_value)
encoded[item_name] = item_value
return encoded
class UpdateEncoder(OperatorEncoder):
"""Encode update specs."""
ops = {
'$inc': 'scalar',
'$mul': 'scalar',
'$rename': 'str',
'$setOnInsert': 'scalar',
'$set': 'scalar',
'$unset': 'unset',
'$min': 'scalar',
'$max': 'scalar',
'$currentDate': 'currentdate',
'$addToSet': 'add',
'$pop': 'int',
'$pullAll': 'array',
'$pull': 'field_or_query',
'$pushAll': 'array',
'$push': 'push',
'$bit': 'bitwise',
}
def __init__(self, document):
"""Create an encoder for the given document class."""
self.document = document
def is_positional(self, name):
"""Return True if the field name has a positional operator attached."""
return name[-2:] == '.$'
def get_field_name(self, name):
"""Return a clean field name."""
if self.is_positional(name):
return name[:-2]
return name
def get_field(self, name):
"""Return a named document field."""
name = self.get_field_name(name)
return super(UpdateEncoder, self).get_field(name)
def encode_scalar(self, name, value):
"""Encode a scalar update value."""
if self.is_positional(name):
return self.encode_array_element(name, value)
field = self.get_field(name)
if field:
return field.encode(self.document, name, value)
return self.encode_default(name, value)
def encode_unset(self, name, value):
"""Encode an unset update value."""
return ''
def encode_array(self, name, values):
"""Encode an array update value."""
field = self.get_field(name)
if field:
if self.is_array_value(values):
if self.is_array_field(field):
values = field.encode(self.document, name, values)
else:
values = [field.encode(self.document, name, value) for value in values]
else:
if self.is_array_field(field):
values = field.typ.encode_element(self.document, name, values)
else:
values = field.encode(self.document, name, values)
else:
values = self.encode_default(name, values)
return values
def encode_array_element(self, name, value):
"""Encode an array element update value."""
field = self.get_field(name)
if field:
if self.is_array_field(field):
return field.typ.encode_element(self.document, name, value)
else:
return field.typ.encode(self.document, name, value)
return self.encode_default(name, value)
def encode_add(self, name, value):
"""Encode an value for adding to a set."""
if isinstance(value, dict):
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
if item_name == '$each':
encoded[item_name] = self.encode_array(name, item_value)
else:
encoded[item_name] = self.encode_default(name, item_value)
value = encoded
else:
value = self.encode_array_element(name, value)
return value
def encode_sort(self, name, value):
"""Encode a sort spec."""
return SortEncoder(self.document).encode(value)
def encode_push(self, name, value):
"""Encode a push update value."""
if isinstance(value, dict):
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
if item_name == '$each':
encoded[item_name] = self.encode_array(name, item_value)
elif item_name == '$slice':
encoded[item_name] = self.encode_int(name, item_value)
elif item_name == '$sort':
encoded[item_name] = self.encode_sort(name, item_value)
elif item_name == '$position':
encoded[item_name] = self.encode_int(name, item_value)
else:
encoded[item_name] = self.encode_default(name, item_value)
value = encoded
else:
value = self.encode_array_element(name, value)
return value
def encode_query(self, name, value):
"""Encode a query update value."""
from .query import Query
if not isinstance(value, Query):
value = Query(value)
return value.encode(self.document)
def encode_field_or_query(self, name, value):
"""Encode a query update value."""
from .query import Query
if isinstance(value, Query):
return value.encode(self.document)
else:
return QueryEncoder(self.document).encode_field(name, value)
def encode_currentdate(self, name, value):
"""Encode a currentdate value."""
if isinstance(value, dict):
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
if item_name == '$type':
encoded[item_name] = self.encode_str(name, item_value)
else:
encoded[item_name] = self.encode_default(name, item_value)
value = encoded
else:
value = bool(value)
return value
def encode_bitwise(self, name, value):
"""Encode a bitwise value."""
try:
value = OrderedDict(value)
except (TypeError, ValueError):
raise EncodingError("unable to encode bitwise value", self.document, name, value)
encoded = OrderedDict()
for item_name, item_value in six.iteritems(value):
encoded[str(item_name)] = self.encode_int(name, item_value)
return encoded
def encode(self, value):
"""Return an encoded update value."""
if not value:
return None
try:
value = OrderedDict(value)
except (TypeError, ValueError):
raise EncodingError("unable to encode update", self.document, '<update>', value=value)
encoded = OrderedDict()
for op, values in six.iteritems(value):
encode_method = self.get_encode_method(op)
encoded_update = OrderedDict()
for name, value in six.iteritems(values):
encoded_update[name] = encode_method(name, value)
encoded[op] = encoded_update
return encoded
| {
"repo_name": "WiFast/bearfield",
"path": "bearfield/encoders.py",
"copies": "1",
"size": "16702",
"license": "bsd-3-clause",
"hash": -2783234003826323000,
"line_mean": 34.6119402985,
"line_max": 98,
"alpha_frac": 0.5609507843,
"autogenerated": false,
"ratio": 4.325822325822326,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5386773110122326,
"avg_score": null,
"num_lines": null
} |
"""Additional dataset classes."""
from __future__ import (division, print_function, )
from collections import OrderedDict
from scipy.stats import multivariate_normal
import numpy as np
import numpy.random as npr
from fuel import config
from fuel.datasets import H5PYDataset, IndexableDataset
from fuel.transformers.defaults import uint8_pixels_to_floatX
from fuel.utils import find_in_data_path
from ali.utils import as_array
class TinyILSVRC2012(H5PYDataset):
"""The Tiny ILSVRC2012 Dataset.
Parameters
----------
which_sets : tuple of str
Which split to load. Valid values are 'train' (1,281,167 examples)
'valid' (50,000 examples), and 'test' (100,000 examples).
"""
filename = 'ilsvrc2012_tiny.hdf5'
default_transformers = uint8_pixels_to_floatX(('features',))
def __init__(self, which_sets, **kwargs):
kwargs.setdefault('load_in_memory', False)
super(TinyILSVRC2012, self).__init__(
file_or_path=find_in_data_path(self.filename),
which_sets=which_sets, **kwargs)
class GaussianMixture(IndexableDataset):
""" Toy dataset containing points sampled from a gaussian mixture distribution.
The dataset contains 3 sources:
* features
* label
* densities
"""
def __init__(self, num_examples, means=None, variances=None, priors=None,
**kwargs):
rng = kwargs.pop('rng', None)
if rng is None:
seed = kwargs.pop('seed', config.default_seed)
rng = np.random.RandomState(seed)
gaussian_mixture = GaussianMixtureDistribution(means=means,
variances=variances,
priors=priors,
rng=rng)
self.means = gaussian_mixture.means
self.variances = gaussian_mixture.variances
self.priors = gaussian_mixture.priors
features, labels = gaussian_mixture.sample(nsamples=num_examples)
densities = gaussian_mixture.pdf(x=features)
data = OrderedDict([
('features', features),
('label', labels),
('density', densities)
])
super(GaussianMixture, self).__init__(data, **kwargs)
class GaussianMixtureDistribution(object):
""" Gaussian Mixture Distribution
Parameters
----------
means : tuple of ndarray.
Specifies the means for the gaussian components.
variances : tuple of ndarray.
Specifies the variances for the gaussian components.
priors : tuple of ndarray
Specifies the prior distribution of the components.
"""
def __init__(self, means=None, variances=None, priors=None, rng=None, seed=None):
if means is None:
means = map(lambda x: 10.0 * as_array(x), [[0, 0],
[1, 1],
[-1, -1],
[1, -1],
[-1, 1]])
# Number of components
self.ncomponents = len(means)
self.dim = means[0].shape[0]
self.means = means
# If prior is not specified let prior be flat.
if priors is None:
priors = [1.0/self.ncomponents for _ in range(self.ncomponents)]
self.priors = priors
# If variances are not specified let variances be identity
if variances is None:
variances = [np.eye(self.dim) for _ in range(self.ncomponents)]
self.variances = variances
assert len(means) == len(variances), "Mean variances mismatch"
assert len(variances) == len(priors), "prior mismatch"
if rng is None:
rng = npr.RandomState(seed=seed)
self.rng = rng
def _sample_prior(self, nsamples):
return self.rng.choice(a=self.ncomponents,
size=(nsamples, ),
replace=True,
p=self.priors)
def sample(self, nsamples):
# Sampling priors
samples = []
fathers = self._sample_prior(nsamples=nsamples).tolist()
for father in fathers:
samples.append(self._sample_gaussian(self.means[father],
self.variances[father]))
return as_array(samples), as_array(fathers)
def _sample_gaussian(self, mean, variance):
# sampling unit gaussians
epsilons = self.rng.normal(size=(self.dim, ))
return mean + np.linalg.cholesky(variance).dot(epsilons)
def _gaussian_pdf(self, x, mean, variance):
return multivariate_normal.pdf(x, mean=mean, cov=variance)
def pdf(self, x):
"Evaluates the the probability density function at the given point x"
pdfs = map(lambda m, v, p: p * self._gaussian_pdf(x, m, v),
self.means, self.variances, self.priors)
return reduce(lambda x, y: x + y, pdfs, 0.0)
if __name__ == '__main__':
means = map(lambda x: as_array(x), [[0, 0],
[1, 1],
[-1, -1],
[1, -1],
[-1, 1]])
std = 0.01
variances = [np.eye(2) * std for _ in means]
priors = [1.0/len(means) for _ in means]
gaussian_mixture = GaussianMixtureDistribution(means=means,
variances=variances,
priors=priors)
gmdset = GaussianMixture(1000, means, variances, priors, sources=('features', ))
| {
"repo_name": "IshmaelBelghazi/ALI",
"path": "ali/datasets.py",
"copies": "1",
"size": "5781",
"license": "mit",
"hash": 3808113923672862000,
"line_mean": 35.13125,
"line_max": 85,
"alpha_frac": 0.5448884276,
"autogenerated": false,
"ratio": 4.204363636363636,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.00772060859227412,
"num_lines": 160
} |
""" Additional datasets for Nilearn
Function to fetch abide movements
"""
import os
import collections
import numpy as np
from sklearn.datasets.base import Bunch
from nilearn.datasets import _fetch_files, _get_dataset_dir
def _filter_column(array, col, criteria):
""" Return index array matching criteria
Parameters
----------
array: numpy array with columns
Array in which data will be filtered
col: string
Name of the column
criteria: integer (or float), pair of integers, string or list of these
if integer, select elements in column matching integer
if a tuple, select elements between the limits given by the tuple
if a string, select elements that match the string
"""
# Raise an error if the column does not exist
array[col]
if not isinstance(criteria, basestring) and \
not isinstance(criteria, tuple) and \
isinstance(criteria, collections.Iterable):
filter = np.zeros(array.shape, dtype=np.bool)
for criterion in criteria:
filter = np.logical_or(filter,
_filter_column(array, col, criterion))
return filter
if isinstance(criteria, tuple):
if len(criteria) != 2:
raise ValueError("An interval must have 2 values")
if criteria[0] is None:
return array[col] <= criteria[1]
if criteria[1] is None:
return array[col] >= criteria[0]
filter = array[col] <= criteria[1]
return np.logical_and(filter, array[col] >= criteria[0])
return array[col] == criteria
def _filter_columns(array, filters):
filter = np.ones(array.shape, dtype=np.bool)
for column in filters:
filter = np.logical_and(filter,
_filter_column(array, column, filters[column]))
return filter
def fetch_abide_movements(data_dir=None, n_subjects=None, sort=True, verbose=0,
**kwargs):
""" Load ABIDE dataset
The ABIDE dataset must be installed in the data_dir (or NILEARN_DATA env)
into an 'ABIDE' folder. The Phenotypic information file should be in this
folder too.
Parameters
----------
SUB_ID: list of integers in [50001, 50607], optional
Ids of the subjects to be loaded.
DX_GROUP: integer in {1, 2}, optional
1 is autism, 2 is control
DSM_IV_TR: integer in [0, 4], optional
O is control, 1 is autism, 2 is Asperger, 3 is PPD-NOS,
4 is Asperger or PPD-NOS
AGE_AT_SCAN: float in [6.47, 64], optional
Age of the subject
SEX: integer in {1, 2}, optional
1 is male, 2 is female
HANDEDNESS_CATEGORY: string in {'R', 'L', 'Mixed', 'Ambi'}, optional
R = Right, L = Left, Ambi = Ambidextrous
HANDEDNESS_SCORE: integer in [-100, 100], optional
Positive = Right, Negative = Left, 0 = Ambidextrous
"""
name_csv = 'Phenotypic_V1_0b.csv'
dataset_dir = _get_dataset_dir('abide_movements', data_dir=data_dir)
#path_csv = _fetch_files('abide_movements', [(name_csv,
# 'file:' + os.path.join('dataset', name_csv), {})],
# data_dir=data_dir)[0]
path_csv = _fetch_files('abide_movements', [(name_csv,
'file:' + os.path.join('dataset', name_csv), {})])[0]
# The situation is a bit complicated here as we will load movements
# depending on whether they are provided or not. We load a file just to
# download the movements files.
sort_csv = _fetch_files('abide_movements', [('sort.csv',
'file:' + os.path.join('dataset', 'abide_movements.tgz'), {'uncompress':
True})])[0]
sort_csv = np.genfromtxt(sort_csv, delimiter=',', dtype=None)
pheno = np.genfromtxt(path_csv, names=True, delimiter=',', dtype=None)
if sort:
pheno = pheno[_filter_columns(pheno, {
'SUB_ID': sort_csv[sort_csv['f2'] == 1]['f1']})]
filter = _filter_columns(pheno, kwargs)
pheno = pheno[filter]
site_id_to_path = {
'CALTECH': 'Caltech',
'CMU': 'CMU',
'KKI': 'KKI',
'LEUVEN_1': 'Leuven',
'LEUVEN_2': 'Leuven',
'MAX_MUN': 'MaxMun',
'NYU': 'NYU',
'OHSU': 'OHSU',
'OLIN': 'Olin',
'PITT': 'Pitt',
'SBL': 'SBL',
'SDSU': 'SDSU',
'STANFORD': 'Stanford',
'TRINITY': 'Trinity',
'UCLA_1': 'UCLA',
'UCLA_2': 'UCLA',
'UM_1': 'UM',
'UM_2': 'UM',
'USM': 'USM',
'YALE': 'Yale'
}
# Get the files for all remaining subjects
movement = []
filter = np.zeros(pheno.shape, dtype=np.bool)
for i, (site, id) in enumerate(pheno[['SITE_ID', 'SUB_ID']]):
folder = site_id_to_path[site] + '_' + str(id)
base = os.path.join(dataset_dir, folder)
mov = os.path.join(base, 'rp_deleteorient_rest.txt')
if os.path.exists(mov):
movement.append(np.loadtxt(mov))
filter[i] = True
else:
filter[i] = False
pheno = pheno[filter]
# Crop subjects if needed
if n_subjects is not None:
pheno = pheno[:n_subjects]
movement = movement[:n_subjects]
return Bunch(pheno=pheno, movement=movement)
| {
"repo_name": "AlexandreAbraham/movements",
"path": "nilearn_private/more_datasets.py",
"copies": "1",
"size": "5318",
"license": "mit",
"hash": -7338085498414197000,
"line_mean": 30.6547619048,
"line_max": 80,
"alpha_frac": 0.5802933434,
"autogenerated": false,
"ratio": 3.4599869876382563,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4540280331038256,
"avg_score": null,
"num_lines": null
} |
''' additional_datastructures.py: File containing custom utility data structures for use in simple_rl. '''
import json
class SimpleRLStack(object):
''' Implementation for a basic Stack data structure '''
def __init__(self, _list=None):
'''
Args:
_list (list) : underlying elements in the stack
'''
self._list = _list if _list is not None else []
def __repr__(self):
r = ''
for element in self._list:
r += str(element) + ', '
return r
def push(self, element):
return self._list.append(element)
def pop(self):
if len(self._list) > 0:
return self._list.pop()
return None
def peek(self):
if len(self._list) > 0:
return self._list[-1]
return None
def is_empty(self):
return len(self._list) == 0
def size(self):
return len(self._list)
class TupleEncoder(json.JSONEncoder):
'''
A simple class for adding tuple encoding to json, from:
https://stackoverflow.com/questions/15721363/preserve-python-tuples-with-json
'''
def encode(self, obj):
'''
Args:
obj (Object): Arbitrary object to encode in JSON.
Summary:
Converts all tuples into dictionaries of two elements:
(1) "tuple":true
(2) "items:"<tuple_contents>
To be used with the below static method (hinted_tuple_hook) to encode/decode json tuples.
'''
def hint_tuples(item):
if isinstance(item, tuple):
return {'__tuple__': True, 'items': item}
if isinstance(item, list):
return [hint_tuples(e) for e in item]
if isinstance(item, dict):
return {key: hint_tuples(value) for key, value in item.items()}
else:
return item
return json.JSONEncoder.encode(self, hint_tuples(obj))
@staticmethod
def hinted_tuple_hook(obj):
if '__tuple__' in obj.keys():
return tuple(obj['items'])
else:
return obj
| {
"repo_name": "david-abel/simple_rl",
"path": "simple_rl/utils/additional_datastructures.py",
"copies": "1",
"size": "2155",
"license": "apache-2.0",
"hash": -5759182819550566000,
"line_mean": 28.5205479452,
"line_max": 106,
"alpha_frac": 0.543387471,
"autogenerated": false,
"ratio": 4.292828685258964,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5336216156258964,
"avg_score": null,
"num_lines": null
} |
"""Additional Enrichment models"""
import enrichment_model as em
from scipy.special import i0
import numpy as np
class EnrichmentModel2_recur(em.EnrichmentModel2):
def __init__(self, kappa=1, span=0.2, mean_recur=None, **kwargs):
super(EnrichmentModel2_recur, self).__init__(**kwargs)
self.params['kappa'] = kappa
self.params['span'] = span
self.params['mean_recur'] = mean_recur
self.flatten()
self.recur_by_position = self._recur_by_position_theoretical
def copy(self):
new_model = super(EnrichmentModel2_recur, self).copy()
new_model.recur_by_position = new_model._recur_by_position_theoretical
return new_model
def _recur_by_position_theoretical(self, positions):
"""Model as a vonMises distribution centered at the reward with
dispersion kappa
"""
kappa = self.params['kappa']
span = self.params['span']
mean_recur = self.params['mean_recur']
if mean_recur is None:
mean_recur = self._recur_by_position(positions).mean()
def vm(x):
return np.exp(kappa * np.cos(x)) / (2 * np.pi * i0(kappa))
prob = np.array(map(vm, positions))
# Normalize prob such that max - min = span and
# mean = mean of original recur by position
prob -= prob.min()
prob /= prob.max()
prob *= span
return prob - prob.mean() + mean_recur
class EnrichmentModel2_offset(em.EnrichmentModel2):
def __init__(self, alpha=1, mean_b=None, **kwargs):
super(EnrichmentModel2_offset, self).__init__(**kwargs)
self.params['alpha'] = alpha
self.params['mean_b'] = mean_b
self.flatten()
self.shift_mean_var = self._shift_mean_var_theoretical_offset
def copy(self):
new_model = super(EnrichmentModel2_offset, self).copy()
new_model.shift_mean_var = new_model._shift_mean_var_theoretical_offset
return new_model
def _shift_mean_var_theoretical_offset(self, positions):
bs, ks = self._shift_mean_var_flat(positions)
alpha = self.params['alpha']
mean_b = self.params['mean_b']
if mean_b is None:
mean_b = bs.mean()
def sin(x):
return -1 * alpha * np.sin(x) + mean_b
offset = np.array(map(sin, positions))
return offset, ks
class EnrichmentModel2_var(em.EnrichmentModel2):
def __init__(self, kappa=1, alpha=0.2, mean_k=None, **kwargs):
super(EnrichmentModel2_var, self).__init__(**kwargs)
self.params['kappa'] = kappa
self.params['alpha'] = alpha
self.params['mean_k'] = mean_k
self.flatten()
self.shift_mean_var = self._shift_mean_var_theoretical_var
def copy(self):
new_model = super(EnrichmentModel2_var, self).copy()
new_model.shift_mean_var = new_model._shift_mean_var_theoretical_var
return new_model
def _shift_mean_var_theoretical_var(self, positions):
bs, ks = self._shift_mean_var_flat(positions)
kappa = self.params['kappa']
alpha = self.params['alpha']
mean_k = self.params['mean_k']
if mean_k is None:
mean_k = ks.mean()
def vm(x):
return alpha * np.exp(kappa * np.cos(x)) / (2 * np.pi * i0(kappa))
var = np.array(map(vm, positions))
var -= var.mean()
var += mean_k
return bs, var
if __name__ == '__main__':
import sys
sys.path.insert(0, '/home/jeff/code/df/reward_remap_paper/supplementals')
import matplotlib.pyplot as plt
import cPickle as pkl
import model_swap_parameters as msp
WT_params_path = '/analysis/Jeff/reward_remap/data/enrichment_model/WT_model_params_C.pkl'
WT_params = pkl.load(open(WT_params_path, 'r'))
WT_model_orig = em.EnrichmentModel2(**WT_params)
recur_model_orig = EnrichmentModel2_recur(kappa=1, span=0.8, mean_recur=0.4, **WT_params)
offset_model_orig = EnrichmentModel2_offset(alpha=0.25, **WT_params)
var_model_orig = EnrichmentModel2_var(kappa=1, alpha=10, mean_k=3, **WT_params)
WT_model = WT_model_orig.copy()
th_model = var_model_orig.copy()
# WT_model.interpolate(Df_model_orig, shift_b=1)
# Df_model.interpolate(WT_model_orig, shift_b=1)
WT_model.initialize(n_cells=1000)
th_model.initialize_like(WT_model)
initial_mask = WT_model.mask
initial_positions = WT_model.positions
WT_masks, WT_positions = [], []
th_masks, th_positions = [], []
n_runs = 100
for _ in range(n_runs):
WT_model.initialize(initial_mask=initial_mask, initial_positions=initial_positions)
th_model.initialize(initial_mask=initial_mask, initial_positions=initial_positions)
WT_model.run(8)
th_model.run(8)
WT_masks.append(WT_model._masks)
WT_positions.append(WT_model._positions)
th_masks.append(th_model._masks)
th_positions.append(th_model._positions)
WT_enrich = msp.calc_enrichment(WT_positions, WT_masks)
th_enrich = msp.calc_enrichment(th_positions, th_masks)
msp.plot_enrichment(plt.axes(), WT_enrich, th_enrich, 'b', 'r', 'Enrich')
from pudb import set_trace; set_trace()
| {
"repo_name": "losonczylab/Zaremba_NatNeurosci_2017",
"path": "enrichment_model/enrichment_model_theoretical.py",
"copies": "1",
"size": "5272",
"license": "mit",
"hash": -7173605994464979000,
"line_mean": 26.8941798942,
"line_max": 94,
"alpha_frac": 0.6170333839,
"autogenerated": false,
"ratio": 3.2463054187192117,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4363338802619212,
"avg_score": null,
"num_lines": null
} |
"""Additional features for templates."""
from os.path import dirname, join, isfile
from django import VERSION
from django.template.base import Origin
from django.template.loaders.filesystem import Loader as FilesystemLoader
class BaseLoader(FilesystemLoader):
"""Custom base loader for templates."""
_app_dir = dirname(__file__)
def _generate_template_source(self, template_name, design):
"""Generate template source."""
template_source = join(
self._app_dir,
'templates',
design,
template_name
)
if isfile(template_source):
if VERSION[:2] >= (1, 9):
template_source = Origin(name=template_source)
return [template_source]
return []
class BootstrapLoader(BaseLoader):
"""Custom loader for Material templates."""
def get_template_sources(self, template_name, template_dirs=None):
"""Override the default GeoKey template with custom Bootstrap UWUM."""
return self._generate_template_source(template_name, 'bootstrap')
class MaterialLoader(BaseLoader):
"""Custom loader for Material templates."""
def get_template_sources(self, template_name, template_dirs=None):
"""Override the default GeoKey template with custom Material UWUM."""
return self._generate_template_source(template_name, 'material')
| {
"repo_name": "ExCiteS/geokey-wegovnow",
"path": "geokey_wegovnow/templates.py",
"copies": "1",
"size": "1398",
"license": "mit",
"hash": -8760904891046444000,
"line_mean": 30.0666666667,
"line_max": 78,
"alpha_frac": 0.6623748212,
"autogenerated": false,
"ratio": 4.509677419354839,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5672052240554839,
"avg_score": null,
"num_lines": null
} |
"""additional fields for consent records
Revision ID: 60486b6dab35
Revises: 898171d91a3e, e9a549d1882d, 6079f2fae734
Create Date: 2021-06-15 07:46:01.937649
"""
from alembic import op
import sqlalchemy as sa
import rdr_service.model.utils
# revision identifiers, used by Alembic.
revision = '60486b6dab35'
down_revision = ('898171d91a3e', 'e9a549d1882d', '6079f2fae734')
branch_labels = None
depends_on = None
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('consent_file', sa.Column('expected_sign_date', sa.Date(), nullable=True))
op.add_column('consent_file', sa.Column('file_path', sa.String(length=250), nullable=True))
op.add_column('consent_file', sa.Column('file_upload_time', rdr_service.model.utils.UTCDateTime(), nullable=True))
# ### end Alembic commands ###
def downgrade_rdr():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_column('consent_file', 'file_upload_time')
op.drop_column('consent_file', 'file_path')
op.drop_column('consent_file', 'expected_sign_date')
# ### end Alembic commands ###
def upgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
def downgrade_metrics():
# ### commands auto generated by Alembic - please adjust! ###
pass
# ### end Alembic commands ###
| {
"repo_name": "all-of-us/raw-data-repository",
"path": "rdr_service/alembic/versions/60486b6dab35_additional_fields_for_consent_records.py",
"copies": "1",
"size": "1549",
"license": "bsd-3-clause",
"hash": 7458591249107243000,
"line_mean": 27.6851851852,
"line_max": 118,
"alpha_frac": 0.6797934151,
"autogenerated": false,
"ratio": 3.2203742203742203,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.44001676354742203,
"avg_score": null,
"num_lines": null
} |
"""Additional form validators
"""
# future imports
from __future__ import absolute_import
# stdlib import
import re
from StringIO import StringIO
# third-party imports
from PIL import Image
from wtforms import ValidationError
from wtforms import validators
# Pulled from http://www.regular-expressions.info/email.html
email_re = re.compile(
r"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*"
r"@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?",
re.IGNORECASE
)
def validate_email_address(form, field):
"""Validate a string email address against the email regex
"""
if (not isinstance(field.data, basestring) or
not email_re.search(field.data)):
raise ValidationError('Not a valid email address.')
def validate_image_format(form, field):
"""Use PIL to inspect an image, to see its format type.
"""
valid_formats = ['JPG', 'JPEG', 'PNG']
if len(field.raw_data):
if hasattr(field.raw_data[0], 'filename'):
try:
i = Image.open(StringIO(field.raw_data[0].value))
if i.format not in valid_formats:
raise ValidationError('Invalid image provided.')
except IOError:
raise ValidationError('Invalid image format found.')
def validate_image_size(width=None, height=None):
def _validate_image_size(form, field):
if len(field.raw_data):
if hasattr(field.raw_data[0], 'filename'):
try:
i = Image.open(StringIO(field.raw_data[0].value))
if (width and height) and ((width, height) != i.size):
raise ValidationError(
'Image must be {}x{}, found {}x{}.'.format(
width,
height,
i.size[0],
i.size[1]
)
)
elif width and width != i.size[0]:
raise ValidationError(
'Image must be {}px in width, found {}px.'.format(
width,
i.size[0]
)
)
elif height and height != i.size[1]:
raise ValidationError(
'Image must be {}px in height, found {}px.'.format(
height,
i.size[1]
)
)
except IOError:
raise ValidationError('Invalid image format found.')
return _validate_image_size
class RequiredIf(validators.Required):
"""A validator which makes a field required if
another field is set and has a truthy value.
"""
other_field_name = None
exta_validators = []
def __init__(self, other_field_name, *args, **kwargs):
self.other_field_name = other_field_name
self.exta_validators = args
super(RequiredIf, self).__init__(*args, **kwargs)
def __call__(self, form, field):
other_field = form._fields.get(self.other_field_name)
if other_field is None:
raise Exception(
'no field named "%s" in form' % self.other_field_name)
if bool(other_field.data):
super(RequiredIf, self).__call__(form, field)
for val in self.exta_validators:
val.__call__(form, field)
| {
"repo_name": "mjmcconnell/sra",
"path": "src-server/app/forms/utils/validators.py",
"copies": "1",
"size": "3603",
"license": "apache-2.0",
"hash": -3344695934838971000,
"line_mean": 32.9905660377,
"line_max": 79,
"alpha_frac": 0.4979184013,
"autogenerated": false,
"ratio": 4.263905325443787,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 106
} |
'Additional functions for Keras'
# Authors: Afshine Amidi <lastname@mit.edu>
# Shervine Amidi <firstname@stanford.edu>
# MIT License
import os.path
import itertools
import numpy as np
from keras.callbacks import Callback
from enzynet.indicators import Indicators
from enzynet.real_time import RealTimePlot
from enzynet.tools import dict_to_csv
from enzynet.volume import VolumeDataGenerator
from matplotlib import pyplot as plt
from tqdm import tqdm
current_directory = os.path.dirname(os.path.abspath(__file__))
precomputed_path = os.path.join(current_directory, '../files/precomputed/')
PDB_path = os.path.join(current_directory, '../files/PDB/')
methods = ['confusion_matrix', 'accuracy',
'precision_per_class', 'recall_per_class', 'f1_per_class',
'macro_precision', 'macro_recall', 'macro_f1']
class Voting(VolumeDataGenerator):
"""
Predicts classes of testing enzymes
Parameters
----------
voting_type : string in {'probabilities', 'classes'} (optional, default is
'probabilities')
Probabilistic- or class-based voting.
augmentation : list of strings in {'None', 'flips', 'weighted_flips'}
(optional, default is ['None'])
List of data augmentation options to perform during testing phase.
v_size : int (optional, default is 32)
Size of each side of the output volumes.
directory_precomputed : string (optional, default points to 'files/precomputed')
Path of the precomputed files.
directory_pdb : string (optional, default points to 'files/PDB')
Path of the PDB files.
labels : dict
Dictionary linking PDB IDs to their labels.
list_enzymes : list of strings
List of enzymes.
shuffle : boolean (optional, default is True)
If True, shuffles order of exploration.
p : int (optional, default is 5)
Interpolation of enzymes with p added coordinates between each pair
of consecutive atoms.
max_radius : float (optional, default is 40)
Maximum radius of sphere that will completely fit into the volume.
noise_treatment : boolean (optional, default is False)
If True, voxels with no direct neighbor will be deleted.
weights : list of strings (optional, default is [])
List of weights (among the values ['hydropathy', 'charge']) to consider
as additional channels.
scaling_weights : boolean (optional, default is True)
If True, divides all weights by the weight that is maximum in absolute
value.
"""
def __init__(self, list_enzymes, labels, voting_type='probabilities', augmentation=['None'],
v_size=32, directory_precomputed=precomputed_path,
directory_pdb=PDB_path, shuffle=True, p=5, max_radius=40,
noise_treatment=False, weights=[], scaling_weights=True):
'Initialization'
VolumeDataGenerator.__init__(self, list_enzymes, labels, v_size=v_size, flips=(0, 0, 0),
batch_size=1, directory_precomputed=directory_precomputed,
directory_pdb=directory_pdb, shuffle=shuffle, p=p,
max_radius=max_radius, noise_treatment=noise_treatment,
weights=weights, scaling_weights=scaling_weights)
self.voting_type = voting_type
self.augmentation = augmentation
def predict(self, model):
'Predicts classes of testing enzymes'
# Initialization
self.y_pred = np.empty((len(self.list_enzymes), len(self.augmentation)), dtype=int)
self.y_true = np.array([self.labels[enzyme] for enzyme in self.list_enzymes], dtype=int)
self.y_id = np.array(self.list_enzymes)
# Computations
for j, augmentation in enumerate(self.augmentation):
print('Augmentation: {0}'.format(augmentation))
for i, enzyme in enumerate(tqdm(self.list_enzymes)):
self.y_pred[i,j] = \
self.__vote(model, enzyme, augmentation)
def get_assessment(self):
'Compute several performance indicators'
for j, augmentation in enumerate(self.augmentation):
print('Augmentation: {0}'.format(augmentation))
indicators = Indicators(self.y_true, self.y_pred[:,j])
for method in methods:
getattr(indicators, method)()
def __vote(self, model, enzyme, augmentation):
# Initialization
probability = np.zeros((1, 6))
# Nothing
if augmentation == 'None':
# Store configuration
self.flips = (0, 0, 0)
# Generate volume
X = self._VolumeDataGenerator__data_augmentation([enzyme])[0]
# Voting by adding probabilities
if self.voting_type == 'probabilities':
probability += model.predict_proba(X, verbose=0)
elif self.voting_type == 'classes':
probability[0, model.predict_classes(X, verbose=0)[0]] += 1
# Flips
elif augmentation == 'flips':
# Generate all possibilities
generator_flips = itertools.product(range(2), repeat=3)
# Computations
for flip in generator_flips:
# Store configuration
self.flips = flip
# Generate volume
X = self._VolumeDataGenerator__data_augmentation([enzyme])[0]
# Voting by adding probabilities
if self.voting_type == 'probabilities':
probability += model.predict_proba(X, verbose=0)
elif self.voting_type == 'classes':
probability[0, model.predict_classes(X, verbose=0)[0]] += 1
# Weighted flips
elif augmentation == 'weighted_flips':
# Generate all possibilities
generator_flips = itertools.product(range(2), repeat=3)
# Computations
for flip in generator_flips:
# Store configuration
self.flips = flip
factor = 1/(sum(flip)+1)
# Generate volume
X = self._VolumeDataGenerator__data_augmentation([enzyme])[0]
# Voting by adding probabilities
if self.voting_type == 'probabilities':
probability += factor * model.predict_proba(X, verbose=0)
elif self.voting_type == 'classes':
probability[0, model.predict_classes(X, verbose=0)[0]] += factor * 1
# Predict label
output_label = np.argmax(probability[0,:]) + 1
return output_label
class MetricsHistory(Callback):
"""
Tracks accuracy and loss in real-time, and plots it.
Parameters
----------
saving_path : string (optional, default is 'test.csv')
Full path to output csv file.
"""
def __init__(self, saving_path='test.csv'):
# Initialization
self.display = RealTimePlot(max_entries=200)
self.saving_path = saving_path
self.epochs = []
self.losses = []
self.val_losses = []
self.accs = []
self.val_accs = []
def on_epoch_end(self, epoch, logs={}):
# Store
self.epochs += [epoch]
self.losses += [logs.get('loss')]
self.val_losses += [logs.get('val_loss')]
self.accs += [logs.get('acc')]
self.val_accs += [logs.get('val_acc')]
# Add point to plot
self.display.add(x=epoch,
y_tr=logs.get('acc'),
y_val=logs.get('val_acc'))
plt.pause(0.001)
# Save to file
dictionary = {'epochs': self.epochs,
'losses': self.losses,
'val_losses': self.val_losses,
'accs': self.accs,
'val_accs': self.val_accs}
dict_to_csv(dictionary, self.saving_path)
| {
"repo_name": "shervinea/enzynet",
"path": "enzynet/keras_utils.py",
"copies": "1",
"size": "8033",
"license": "mit",
"hash": -5236458490415014000,
"line_mean": 34.5442477876,
"line_max": 96,
"alpha_frac": 0.5888211129,
"autogenerated": false,
"ratio": 4.069402228976697,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5158223341876698,
"avg_score": null,
"num_lines": null
} |
'''Additional functions
prediction standard errors and confidence intervals
A: josef pktd
'''
import numpy as np
from scipy import stats
import scikits.statsmodels as sm
def atleast_2dcol(x):
''' convert array_like to 2d from 1d or 0d
not tested because not used
'''
x = np.asarray(x)
if (x.ndim == 1):
x = x[:, None]
elif (x.ndim == 0):
x = np.atleast_2d(x)
elif (x.ndim > 0):
raise ValueError, 'too many dimensions'
return x
def wls_prediction_std(res, exog=None, weights=None, alpha=0.05):
'''calculate standard deviation and confidence interval for prediction
applies to WLS and OLS, not to general GLS,
that is independently but not identically distributed observations
Parameters
----------
res : regression result instance
results of WLS or OLS regression required attributes see notes
exog : array_like (optional)
exogenous variables for points to predict
weights : scalar or array_like (optional)
weights as defined for WLS (inverse of variance of observation)
alpha : float (default: alpha = 0.5)
confidence level for two-sided hypothesis
Returns
-------
predstd : array_like, 1d
standard error of prediction
same length as rows of exog
interval_l, interval_u : array_like
lower und upper confidence bounds
Notes
-----
The result instance needs to have at least the following
res.model.predict() : predicted values or
res.fittedvalues : values used in estimation
res.cov_params() : covariance matrix of parameter estimates
If exog is 1d, then it is interpreted as one observation,
i.e. a row vector.
testing status: not compared with other packages
References
----------
Greene p.111 for OLS, extended to WLS by analogy
'''
# work around current bug:
# fit doesn't attach results to model, predict broken
#res.model.results
covb = res.cov_params()
if exog is None:
exog = res.model.exog
predicted = res.fittedvalues
else:
exog = np.atleast_2d(exog)
if covb.shape[1] != exog.shape[1]:
raise ValueError, 'wrong shape of exog'
predicted = res.model.predict(exog)
if weights is None:
weights = res.model.weights
# full covariance:
#predvar = res3.mse_resid + np.diag(np.dot(X2,np.dot(covb,X2.T)))
# predication variance only
predvar = res.mse_resid/weights + (exog * np.dot(covb, exog.T).T).sum(1)
predstd = np.sqrt(predvar)
tppf = stats.t.isf(alpha/2., res.df_resid)
interval_u = predicted + tppf * predstd
interval_l = predicted - tppf * predstd
return predstd, interval_l, interval_u
if __name__ == '__main__':
# generate dataset
nsample = 50
x1 = np.linspace(0, 20, nsample)
X = np.c_[x1, (x1-5)**2, np.ones(nsample)]
np.random.seed(0)#9876789) #9876543)
beta = [0.5, -0.01, 5.]
y_true2 = np.dot(X, beta)
w = np.ones(nsample)
w[nsample*6/10:] = 3
sig = 0.5
y2 = y_true2 + sig*w* np.random.normal(size=nsample)
X2 = X[:,[0,2]]
# estimate OLS, WLS, (OLS not used in these tests)
res2 = sm.OLS(y2, X2).fit()
res3 = sm.WLS(y2, X2, 1./w).fit()
#direct calculation
covb = res3.cov_params()
predvar = res3.mse_resid*w + (X2 * np.dot(covb,X2.T).T).sum(1)
predstd = np.sqrt(predvar)
prstd, iv_l, iv_u = wls_prediction_std(res3)
np.testing.assert_almost_equal(predstd, prstd, 15)
# testing shapes of exog
prstd, iv_l, iv_u = wls_prediction_std(res3, X2[-1:,:], weights=3.)
np.testing.assert_equal( prstd[-1], prstd)
prstd, iv_l, iv_u = wls_prediction_std(res3, X2[-1,:], weights=3.)
np.testing.assert_equal( prstd[-1], prstd)
#use wrong size for exog
#prstd, iv_l, iv_u = wls_prediction_std(res3, X2[-1,0], weights=3.)
np.testing.assert_raises(ValueError, wls_prediction_std, res3, X2[-1,0], weights=3.)
| {
"repo_name": "matthew-brett/draft-statsmodels",
"path": "scikits/statsmodels/sandbox/regression/predstd.py",
"copies": "1",
"size": "3993",
"license": "bsd-3-clause",
"hash": 9041548839718012000,
"line_mean": 28.3602941176,
"line_max": 88,
"alpha_frac": 0.631354871,
"autogenerated": false,
"ratio": 3.238442822384428,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9312023591193022,
"avg_score": 0.011554820438281155,
"num_lines": 136
} |
'''Additional functions
prediction standard errors and confidence intervals
A: josef pktd
'''
import numpy as np
from scipy import stats
def atleast_2dcol(x):
''' convert array_like to 2d from 1d or 0d
not tested because not used
'''
x = np.asarray(x)
if (x.ndim == 1):
x = x[:, None]
elif (x.ndim == 0):
x = np.atleast_2d(x)
elif (x.ndim > 0):
raise ValueError('too many dimensions')
return x
def wls_prediction_std(res, exog=None, weights=None, alpha=0.05):
'''calculate standard deviation and confidence interval for prediction
applies to WLS and OLS, not to general GLS,
that is independently but not identically distributed observations
Parameters
----------
res : regression result instance
results of WLS or OLS regression required attributes see notes
exog : array_like (optional)
exogenous variables for points to predict
weights : scalar or array_like (optional)
weights as defined for WLS (inverse of variance of observation)
alpha : float (default: alpha = 0.05)
confidence level for two-sided hypothesis
Returns
-------
predstd : array_like, 1d
standard error of prediction
same length as rows of exog
interval_l, interval_u : array_like
lower und upper confidence bounds
Notes
-----
The result instance needs to have at least the following
res.model.predict() : predicted values or
res.fittedvalues : values used in estimation
res.cov_params() : covariance matrix of parameter estimates
If exog is 1d, then it is interpreted as one observation,
i.e. a row vector.
testing status: not compared with other packages
References
----------
Greene p.111 for OLS, extended to WLS by analogy
'''
# work around current bug:
# fit doesn't attach results to model, predict broken
#res.model.results
covb = res.cov_params()
if exog is None:
exog = res.model.exog
predicted = res.fittedvalues
if weights is None:
weights = res.model.weights
else:
exog = np.atleast_2d(exog)
if covb.shape[1] != exog.shape[1]:
raise ValueError('wrong shape of exog')
predicted = res.model.predict(res.params, exog)
if weights is None:
weights = 1.
else:
weights = np.asarray(weights)
if weights.size > 1 and len(weights) != exog.shape[0]:
raise ValueError('weights and exog do not have matching shape')
# full covariance:
#predvar = res3.mse_resid + np.diag(np.dot(X2,np.dot(covb,X2.T)))
# predication variance only
predvar = res.mse_resid/weights + (exog * np.dot(covb, exog.T).T).sum(1)
predstd = np.sqrt(predvar)
tppf = stats.t.isf(alpha/2., res.df_resid)
interval_u = predicted + tppf * predstd
interval_l = predicted - tppf * predstd
return predstd, interval_l, interval_u
| {
"repo_name": "bsipocz/statsmodels",
"path": "statsmodels/sandbox/regression/predstd.py",
"copies": "34",
"size": "3000",
"license": "bsd-3-clause",
"hash": -945231561045324500,
"line_mean": 28.702970297,
"line_max": 79,
"alpha_frac": 0.6373333333,
"autogenerated": false,
"ratio": 3.861003861003861,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": null,
"num_lines": null
} |
""" Additional guiqwt tools to facilitate plot navigation.
"""
from PyQt4 import QtGui
from PyQt4.QtCore import Qt
from PyQt4.QtGui import QMessageBox
try:
from PyQt4 import QtCore
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
from guiqwt.tools import CommandTool, DefaultToolbarID, InteractiveTool
from guidata.qthelpers import get_std_icon
from guiqwt.config import _
from guiqwt.events import (setup_standard_tool_filter, PanHandler)
import icons_rc
class HomeTool(CommandTool):
""" A command to show all elements in the plot (same as pressing the
middle mouse button).
"""
def __init__(self, manager, toolbar_id=DefaultToolbarID):
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8(':/Plottools/Home')),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
super(HomeTool, self).__init__(manager, 'Home', icon,
toolbar_id=toolbar_id)
def activate_command(self, plot, checked):
""" Activate that command!
"""
plot.do_autoscale()
class PanTool(InteractiveTool):
""" Allows panning with the left mouse button.
"""
TITLE = _("Pan")
ICON = "move.png"
CURSOR = Qt.OpenHandCursor
def setup_filter(self, baseplot):
filter = baseplot.filter
start_state = filter.new_state()
PanHandler(filter, Qt.LeftButton, start_state=start_state)
return setup_standard_tool_filter(filter, start_state)
class HelpTool(CommandTool):
""" A help tool that includes a message what a single middle click
does, otherwise identical to the guiqwt tool with the same name.
"""
def __init__(self, manager, toolbar_id=DefaultToolbarID):
super(HelpTool,self).__init__(manager, "Help",
get_std_icon("DialogHelpButton", 16),
toolbar_id=toolbar_id)
def activate_command(self, plot, checked):
"""Activate tool"""
QMessageBox.information(plot, "Help",
"""Keyboard/mouse shortcuts:
- single left-click: item (curve, image, ...) selection
- single right-click: context-menu relative to selected item
- single middle click: home
- shift: on-active-curve (or image) cursor
- alt: free cursor
- left-click + mouse move: move item (when available)
- middle-click + mouse move: pan
- right-click + mouse move: zoom""") | {
"repo_name": "rproepp/spykeutils",
"path": "spykeutils/plot/guiqwt_tools.py",
"copies": "1",
"size": "2375",
"license": "bsd-3-clause",
"hash": 6147148450201313000,
"line_mean": 30.68,
"line_max": 72,
"alpha_frac": 0.6703157895,
"autogenerated": false,
"ratio": 3.8183279742765275,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.49886437637765274,
"avg_score": null,
"num_lines": null
} |
""" Additional Haystack Signal Processors
This module provides additional HAYSTACK_SIGNAL_PROCESSOR classes to reindex more effeciently.
They may be tied to various other haystack-related libraries.
They are not tied to `tastypie_search` in any way! Use them anywhere Haystack is installed.
"""
import sys
from django.conf import settings
# TODO: Using "importlib" requires py2.7; find another way.
import inspect
import importlib
from haystack.indexes import SearchIndex
from queued_search.signals import QueuedSignalProcessor
import logging
logger = logging.getLogger(__name__)
def indexed_models():
""" Use introspection to find haystack's indexed models.
These models need to trigger `update_index` when the ORM changes them.
Each application in settings.INSTALLED_APPS must have the module:
import app.search_indexes
... and there must be classes derived from:
import haystack.indexes.SearchIndex
"""
models_list = []
for app in settings.INSTALLED_APPS:
try:
# find app.search_indexes modules in each app...
search_indexes = importlib.import_module('%s.search_indexes' % app)
search_indexes = [ m for n, m in inspect.getmembers(search_indexes, inspect.isclass) if issubclass(m, SearchIndex) ]
logger.debug("%s.search_indexes: %r" % (app, search_indexes))
models_list = [ m().get_model() for m in search_indexes ]
logger.debug("Indexed Models: %r" % models_list)
except ImportError as e:
pass
return models_list
class ModelCheckingQueuedSignalProcessor(QueuedSignalProcessor):
""" This signal processor tells Haystack to queue up only
the models that have full text indexes.
Declare this signal processor class in the django.settings as a full path.
HAYSTACK_SIGNAL_PROCESSOR='tastypie_search.signals.ModelCheckingQueuedSignalProcessor'
"""
def __init__(self, *args, **kwargs):
super(ModelCheckingQueuedSignalProcessor, self).__init__(*args, **kwargs)
self._indexed_models = tuple(indexed_models())
def enqueue_save(self, sender, instance, **kwargs):
if isinstance(instance, self._indexed_models):
return self.enqueue('update', instance)
def enqueue_delete(self, sender, instance, **kwargs):
if isinstance(instance, self._indexed_models):
return self.enqueue('delete', instance)
| {
"repo_name": "adroffner/tastypie-searchable",
"path": "tastypie_search/signals.py",
"copies": "1",
"size": "2443",
"license": "mit",
"hash": -7273136065500973000,
"line_mean": 34.9264705882,
"line_max": 128,
"alpha_frac": 0.6983217356,
"autogenerated": false,
"ratio": 4.1689419795221845,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.019808850341111933,
"num_lines": 68
} |
"""Additional helpful utility functions."""
import sys
from django.conf import settings
try:
from html.parser import HTMLParser
except ImportError:
from HTMLParser import HTMLParser
try:
from bs4 import BeautifulSoup
except ImportError: # pragma: nocover
sys.stderr.write('Warning: BeautifulSoup could not be imported! Created'
' fallback for tests to work.')
def BeautifulSoup(x, y):
return x
class HTML2PlainParser(HTMLParser):
"""Custom html parser to convert html code to plain text."""
def __init__(self):
try:
super(HTML2PlainParser, self).__init__()
except TypeError:
self.reset()
self.text = '' # Used to push the results into a variable
self.links = [] # List of aggregated links
# Settings
self.ignored_elements = getattr(
settings, 'HTML2PLAINTEXT_IGNORED_ELEMENTS',
['html', 'head', 'style', 'meta', 'title', 'img']
)
self.newline_before_elements = getattr(
settings, 'HTML2PLAINTEXT_NEWLINE_BEFORE_ELEMENTS',
['br', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'div', 'p', 'li']
)
self.newline_after_elements = getattr(
settings, 'HTML2PLAINTEXT_NEWLINE_AFTER_ELEMENTS',
['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'div', 'p', 'td']
)
self.stroke_before_elements = getattr(
settings, 'HTML2PLAINTEXT_STROKE_BEFORE_ELEMENTS',
['tr']
)
self.stroke_after_elements = getattr(
settings, 'HTML2PLAINTEXT_STROKE_AFTER_ELEMENTS',
['tr']
)
self.stroke_text = getattr(settings, 'HTML2PLAINTEXT_STROKE_TEXT',
'------------------------------\n')
def handle_starttag(self, tag, attrs):
"""Handles every start tag like e.g. <p>."""
if (tag in self.newline_before_elements):
self.text += '\n'
if (tag in self.stroke_before_elements and not
self.text.endswith(self.stroke_text)):
# Put a stroke in front of every relevant element, if there is some
# content between it and its predecessor
self.text += self.stroke_text
if tag == 'a':
# If it's a link, append it to the link list
for attr in attrs:
if attr[0] == 'href':
self.links.append((len(self.links) + 1, attr[1]))
def handle_data(self, data):
"""Handles data between tags."""
# Only proceed with unignored elements
if self.lasttag not in self.ignored_elements:
# Remove any predefined linebreaks
text = data.replace('\n', '')
# If there's some text left, proceed!
if text:
if self.lasttag == 'li':
# Use a special prefix for list elements
self.text += ' * '
self.text += text
if self.lasttag in self.newline_after_elements:
# Add a linebreak at the end of the content
self.text += '\n'
def handle_endtag(self, tag):
"""Handles every end tag like e.g. </p>."""
if tag in self.stroke_after_elements:
if self.text.endswith(self.stroke_text):
# Only add a stroke if there isn't already a stroke posted
# In this case, there was no content between the tags, so
# remove the starting stroke
self.text = self.text[:-len(self.stroke_text)]
else:
# If there's no linebreak before the stroke, add one!
if not self.text.endswith('\n'):
self.text += '\n'
self.text += self.stroke_text
if tag == 'a':
# If it's a link, add a footnote
self.text += '[{}]'.format(len(self.links))
elif tag == 'br' and self.text and not self.text.endswith('\n'):
# If it's a break, check if there's no break at the end of the
# content. If there's none, add one!
self.text += '\n'
# Reset the lasttag, otherwise this parse can geht confused, if the
# next element is not wrapped in a new tag.
if tag == self.lasttag:
self.lasttag = None
def html_to_plain_text(html):
"""Converts html code into formatted plain text."""
# Use BeautifulSoup to normalize the html
soup = BeautifulSoup(html, "html.parser")
# Init the parser
parser = HTML2PlainParser()
parser.feed(str(soup.encode('utf-8')))
# Strip the end of the plain text
result = parser.text.rstrip()
# Add footnotes
if parser.links:
result += '\n\n'
for link in parser.links:
result += '[{}]: {}\n'.format(link[0], link[1])
return result
| {
"repo_name": "bitmazk/django-libs",
"path": "django_libs/utils/converter.py",
"copies": "1",
"size": "4898",
"license": "mit",
"hash": -9181839672506032000,
"line_mean": 37.873015873,
"line_max": 79,
"alpha_frac": 0.546957942,
"autogenerated": false,
"ratio": 4.085070892410342,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5132028834410342,
"avg_score": null,
"num_lines": null
} |
"""Additional HTTPAdapter subclasses for python `requests` module."""
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.poolmanager import PoolManager
class SSLAdapter(HTTPAdapter):
"""An adapter that allows passing in an arbitrary ssl_version.
Useful because OpenSSL bugs can create situations where Python urllib2 requests can't complete successful
handshakes.
"""
__attrs__ = HTTPAdapter.__attrs__ + ['ssl_version']
def __init__(self, ssl_version=None, **kwargs):
"""Set SSL version on init.
:param ssl_version: one of the ssl constants from stdlib `ssl` module, e.g. ssl.PROTOCOL_TLSv1
:type ssl_version: int
:param kwargs:
"""
self.ssl_version = ssl_version
super(SSLAdapter, self).__init__(**kwargs)
def init_poolmanager(self, connections, maxsize, *args, **kwargs):
"""Force the pool to use this instance's SSL version.
This is a method used internally by HTTPAdapter, don't use it directly.
:param connections:
:param maxsize:
"""
# pylint: disable=unused-argument, attribute-defined-outside-init
self._pool_connections = connections
self._pool_maxsize = maxsize
self.poolmanager = PoolManager(num_pools=connections,
maxsize=maxsize,
ssl_version=self.ssl_version)
| {
"repo_name": "kevinseelbach/generic_utils",
"path": "src/generic_utils/requests_utils.py",
"copies": "1",
"size": "1440",
"license": "bsd-3-clause",
"hash": 3346223347625739000,
"line_mean": 37.9189189189,
"line_max": 109,
"alpha_frac": 0.6388888889,
"autogenerated": false,
"ratio": 4.585987261146497,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5724876150046497,
"avg_score": null,
"num_lines": null
} |
"""Additional IR Pass for VTA"""
# pylint: disable=len-as-condition
from __future__ import absolute_import as _abs
import tvm
from topi import util as util
from .environment import get_env
def _match_pragma(stmt, key):
"""Internal helper to match stmt to pragma stmt.
Parameters
----------
stmt : Stmt
The AttrStmt
key : str
The pragma key
"""
return ((stmt.attr_key == "pragma_" + key) or
(stmt.attr_key == "pragma_scope" and stmt.value.value == key))
def fold_uop_loop(stmt_in):
"""Detect and fold uop loop.
VTA support uop programming model
that recognizes loop structure.
This pass detect the loop structure
and extract that into uop loop AST.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Output statement.
"""
env = get_env()
def _fold_outermost_loop(body):
stmt = body
while not isinstance(stmt, tvm.stmt.For):
if isinstance(stmt, (tvm.stmt.ProducerConsumer,)):
stmt = stmt.body
else:
return None, body, None
loop_var = stmt.loop_var
gemm_offsets = [None, None, None]
fail = [False]
def _post_order(op):
assert isinstance(op, tvm.expr.Call)
base_args = 2
if op.name == "VTAUopPush":
args = []
args += op.args[:base_args]
for i in range(3):
m = tvm.arith.DetectLinearEquation(
op.args[i + base_args], [loop_var])
if not m:
fail[0] = True
return op
if gemm_offsets[i] is not None:
if not tvm.ir_pass.Equal(m[0], gemm_offsets[i]):
fail[0] = True
return op
args.append(m[1])
else:
gemm_offsets[i] = m[0]
args.append(m[1])
args += op.args[base_args+3:]
return tvm.call_extern("int32", "VTAUopPush", *args)
else:
if op.name not in ("VTATLSCommandHandle", "tvm_thread_context"):
raise RuntimeError("unexpected op %s" % op)
return op
ret = tvm.ir_pass.IRTransform(
stmt.body, None, _post_order, ["Call"])
if not fail[0] and all(x is not None for x in gemm_offsets):
def _visit(op):
if op.same_as(loop_var):
fail[0] = True
tvm.ir_pass.PostOrderVisit(ret, _visit)
if not fail[0]:
begin = tvm.call_extern(
"int32", "VTAUopLoopBegin", stmt.extent, *gemm_offsets)
end = tvm.call_extern("int32", "VTAUopLoopEnd")
return [begin, ret, end]
raise ValueError("Failed to fold the GEMM instructions..")
def _do_fold(stmt):
if (stmt.attr_key == "coproc_uop_scope" and
isinstance(stmt.value, tvm.expr.StringImm) and
stmt.value.value == env.dev.vta_push_uop.value):
body = stmt.body
begins = []
ends = []
try:
begin, body, end = _fold_outermost_loop(body)
if begin is not None:
begins.append(begin)
if end is not None:
ends.append(end)
begin, body, end = _fold_outermost_loop(body)
if begin is not None:
begins.append(begin)
if end is not None:
ends.append(end)
except ValueError:
pass
if body == stmt.body:
return stmt
ends = list(reversed(ends))
body = tvm.make.stmt_seq(*(begins + [body] + ends))
return tvm.make.AttrStmt(
stmt.node, stmt.attr_key, stmt.value, body)
return None
out = tvm.ir_pass.IRTransform(
stmt_in, _do_fold, None, ["AttrStmt"])
return out
def cpu_access_rewrite(stmt_in):
"""Detect CPU access to VTA buffer and get address correctly.
VTA's buffer is an opaque handle that do not
correspond to address in CPU.
This pass detect CPU access and rewrite to use pointer
returned VTABufferCPUPtr for CPU access.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
env = get_env()
rw_info = {}
def _post_order(op):
if isinstance(op, tvm.stmt.Allocate):
buffer_var = op.buffer_var
if not buffer_var in rw_info:
return None
new_var = rw_info[buffer_var]
let_stmt = tvm.make.LetStmt(
new_var, tvm.call_extern(
"handle", "VTABufferCPUPtr",
env.dev.command_handle,
buffer_var), op.body)
alloc = tvm.make.Allocate(
buffer_var, op.dtype, op.extents,
op.condition, let_stmt)
del rw_info[buffer_var]
return alloc
elif isinstance(op, tvm.expr.Load):
buffer_var = op.buffer_var
if not buffer_var in rw_info:
rw_info[buffer_var] = tvm.var(
buffer_var.name + "_ptr", "handle")
new_var = rw_info[buffer_var]
return tvm.make.Load(op.dtype, new_var, op.index)
elif isinstance(op, tvm.stmt.Store):
buffer_var = op.buffer_var
if not buffer_var in rw_info:
rw_info[buffer_var] = tvm.var(
buffer_var.name + "_ptr", "handle")
new_var = rw_info[buffer_var]
return tvm.make.Store(new_var, op.value, op.index)
else:
raise RuntimeError("not reached")
stmt = tvm.ir_pass.IRTransform(
stmt_in, None, _post_order, ["Allocate", "Load", "Store"])
for buffer_var, new_var in rw_info.items():
stmt = tvm.make.LetStmt(
new_var, tvm.call_extern(
"handle", "VTABufferCPUPtr",
env.dev.command_handle,
buffer_var), stmt)
return stmt
def lift_alloc_to_scope_begin(stmt_in):
"""Lift allocate to beginning of the current scope.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
lift_stmt = [[]]
def _merge_block(slist, body):
for op in slist:
if op.body == body:
body = op
elif isinstance(op, tvm.stmt.Allocate):
body = tvm.make.Allocate(
op.buffer_var, op.dtype,
op.extents, op.condition, body)
elif isinstance(op, tvm.stmt.AttrStmt):
body = tvm.make.AttrStmt(
op.node, op.attr_key, op.value, body)
elif isinstance(op, tvm.stmt.For):
body = tvm.make.For(
op.loop_var, op.min, op.extent, op.for_type,
op.device_api, body)
else:
raise RuntimeError("unexpected op")
del slist[:]
return body
def _pre_order(op):
if isinstance(op, tvm.stmt.For):
lift_stmt.append([])
elif isinstance(op, tvm.stmt.AttrStmt):
if op.attr_key == "virtual_thread":
lift_stmt.append([])
return None
def _post_order(op):
if isinstance(op, tvm.stmt.Allocate):
lift_stmt[-1].append(op)
return op.body
elif isinstance(op, tvm.stmt.AttrStmt):
if op.attr_key == "storage_scope":
lift_stmt[-1].append(op)
return op.body
elif op.attr_key == "virtual_thread":
return _merge_block(lift_stmt.pop() + [op], op.body)
return op
elif isinstance(op, tvm.stmt.For):
return _merge_block(lift_stmt.pop() + [op], op.body)
else:
raise RuntimeError("not reached")
stmt = tvm.ir_pass.IRTransform(
stmt_in, _pre_order, _post_order, ["Allocate", "AttrStmt", "For"])
assert len(lift_stmt) == 1
return _merge_block(lift_stmt[0], stmt)
def inject_skip_copy(stmt_in):
"""Pass to inject skip copy stmt, used for debug purpose.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
def _do_fold(stmt):
if _match_pragma(stmt, "skip_dma_copy"):
return tvm.make.Evaluate(0)
return None
return tvm.ir_pass.IRTransform(
stmt_in, _do_fold, None, ["AttrStmt"])
def inject_coproc_sync(stmt_in):
"""Pass to inject skip copy stmt, used in debug.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
success = [False]
def _do_fold(stmt):
if _match_pragma(stmt, "coproc_sync"):
success[0] = True
sync = tvm.make.Call(
"int32", "vta.coproc_sync", [], tvm.expr.Call.Intrinsic, None, 0)
return tvm.make.Block(stmt.body, tvm.make.Evaluate(sync))
elif _match_pragma(stmt, "trim_loop"):
op = stmt.body
assert isinstance(op, tvm.stmt.For)
return tvm.make.For(
op.loop_var, op.min, 2, op.for_type,
op.device_api, op.body)
return None
stmt = tvm.ir_pass.IRTransform(
stmt_in, None, _do_fold, ["AttrStmt"])
stmt = tvm.ir_pass.CoProcSync(stmt)
return stmt
def inject_dma_intrin(stmt_in):
"""Pass to inject DMA copy intrinsics.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
env = get_env()
def _check_compact(buf):
ndim = len(buf.shape)
size = tvm.const(1, buf.shape[0].dtype)
for i in reversed(range(ndim)):
if not util.equal_const_int(size - buf.strides[i], 0):
raise RuntimeError(
"Cannot prove compact: shape=%s, strides=%s" % (buf.shape, buf.strides))
size = size * buf.shape[i]
def _fold_buffer_dim(buf, scope, elem_block):
ndim = len(buf.shape)
x_size = 1
base = 0
for i in range(1, ndim + 1):
if not util.equal_const_int(buf.strides[ndim - i] - x_size, 0):
raise RuntimeError("scope %s needs to have block=%d" % (scope, elem_block))
x_size = x_size * buf.shape[ndim - i]
if util.equal_const_int(x_size - elem_block, 0):
base = i + 1
break
if base == 0:
raise RuntimeError("scope %s need to have block=%d, shape=%s" % (
scope, elem_block, buf.shape))
shape = [elem_block]
strides = [1]
if base < ndim + 1 and not util.equal_const_int(buf.strides[ndim - base], elem_block):
shape.append(1)
strides.append(elem_block)
while base < ndim + 1:
x_size = 1
x_stride = buf.strides[ndim - base]
next_base = base
if not util.equal_const_int(x_stride % elem_block, 0):
raise RuntimeError(
"scope %s need to have block=%d, shape=%s, strides=%s" % (
scope, elem_block, buf.shape, buf.strides))
for i in range(base, ndim + 1):
k = ndim - i
if not util.equal_const_int(x_size * x_stride - buf.strides[k], 0):
break
x_size = x_size * buf.shape[k]
next_base = i + 1
shape.append(tvm.ir_pass.Simplify(x_size))
strides.append(x_stride)
assert next_base != base
base = next_base
strides = list(reversed(strides))
shape = list(reversed(shape))
return shape, strides
def _get_2d_pattern(buf, elem_width, elem_bytes, dtype, scope, allow_fold):
elem_block = elem_bytes * 8 // elem_width
if buf.dtype != dtype:
raise RuntimeError("Expect buffer type to be %s instead of %s" %
(dtype, buf.dtype))
shape, strides = buf.shape, buf.strides
if not util.equal_const_int(buf.elem_offset % elem_block, 0):
raise RuntimeError("scope %s need to have block=%d" % (scope, elem_block))
if allow_fold:
shape, strides = _fold_buffer_dim(buf, scope, elem_block)
else:
shape = list(x for x in shape)
strides = list(x for x in strides)
def raise_error():
"""Internal function to raise error """
raise RuntimeError(
("Scope[%s]: cannot detect 2d pattern with elem_block=%d:" +
" shape=%s, strides=%s") % (scope, elem_block, buf.shape, buf.strides))
ndim = len(shape)
# Check if the inner-tensor is already flat
flat = util.equal_const_int(shape[-1], elem_block)
if flat:
if not util.equal_const_int(strides[-1], 1):
raise_error()
if ndim == 1:
x_size = 1
x_stride = 1
y_size = 1
return x_size, y_size, x_stride, buf.elem_offset / elem_block
if not util.equal_const_int(strides[-2] - elem_block, 0):
raise_error()
if ndim == 2:
x_size = shape[-2]
x_stride = shape[-2]
y_size = 1
return x_size, y_size, x_stride, buf.elem_offset / elem_block
if not util.equal_const_int(strides[-3] % elem_block, 0):
raise_error()
if ndim == 3:
x_size = shape[-2]
x_stride = strides[-3] / elem_block
y_size = shape[-3]
return x_size, y_size, x_stride, buf.elem_offset / elem_block
else:
if not util.equal_const_int(strides[-1], 1):
raise_error()
if not util.equal_const_int(strides[-2] - shape[-1], 0):
raise_error()
if not util.equal_const_int(shape[-1] * shape[-2], elem_block):
raise_error()
if ndim == 2:
x_size = 1
x_stride = 1
y_size = 1
return x_size, y_size, x_stride, buf.elem_offset / elem_block
if not util.equal_const_int(strides[-3], elem_block):
raise_error()
if ndim == 3:
x_size = shape[-3]
x_stride = shape[-3]
y_size = 1
return x_size, y_size, x_stride, buf.elem_offset / elem_block
if not util.equal_const_int(strides[-4] % elem_block, 0):
raise_error()
if ndim == 4:
x_size = shape[-3]
x_stride = strides[-4] / elem_block
y_size = shape[-4]
return x_size, y_size, x_stride, buf.elem_offset / elem_block
raise_error()
def _inject_copy(src, dst, pad_before, pad_after, pad_value):
# FIXME: pad_value is ignored...
_ = pad_value
if dst.scope == "global":
# Store
if pad_before or pad_after:
raise RuntimeError("Do not support copy into DRAM with pad")
if src.scope == env.acc_scope:
elem_width = env.OUT_WIDTH
elem_bytes = env.OUT_ELEM_BYTES
mem_type = env.dev.MEM_ID_OUT
data_type = "int%d" % env.OUT_WIDTH
task_qid = env.dev.QID_STORE_OUT
else:
raise RuntimeError("Do not support copy %s->dram" % (src.scope))
_check_compact(src)
x_size, y_size, x_stride, offset = _get_2d_pattern(
dst, elem_width, elem_bytes, data_type, src.scope, allow_fold=True)
irb = tvm.ir_builder.create()
irb.scope_attr(env.dev.vta_axis, "coproc_scope",
env.dev.get_task_qid(task_qid))
irb.emit(tvm.call_extern(
"int32", "VTAStoreBuffer2D",
env.dev.command_handle,
src.access_ptr("r", "int32"),
mem_type, dst.data, offset, x_size, y_size, x_stride))
return irb.get()
elif src.scope == "global":
if dst.scope == env.acc_scope:
elem_width = env.ACC_WIDTH
elem_bytes = env.ACC_ELEM_BYTES
mem_type = env.dev.MEM_ID_ACC
data_type = "int%d" % env.ACC_WIDTH
task_qid = env.dev.QID_LOAD_OUT
elif dst.scope == env.inp_scope:
elem_width = env.INP_WIDTH
elem_bytes = env.INP_ELEM_BYTES
mem_type = env.dev.MEM_ID_INP
data_type = "int%d" % env.INP_WIDTH
task_qid = env.dev.QID_LOAD_INP
elif dst.scope == env.wgt_scope:
elem_width = env.WGT_WIDTH
elem_bytes = env.WGT_ELEM_BYTES
mem_type = env.dev.MEM_ID_WGT
data_type = "int%d" % env.WGT_WIDTH
task_qid = env.dev.QID_LOAD_WGT
else:
raise RuntimeError("Do not support copy dram->%s" % (dst.scope))
# collect pad statistics
if pad_before:
assert pad_after
ndim = len(pad_before)
if ndim <= 2 or ndim > 4:
raise ValueError("Limitation of 2D pad load forbid ndim=%d" % ndim)
if ndim > 2:
if not util.equal_const_int(pad_before[ndim - 1], 0):
raise ValueError("Do not support pad on the innermost block")
if not util.equal_const_int(pad_after[ndim - 1], 0):
raise ValueError("Do not support pad on the innermost block")
if ndim > 3:
if not util.equal_const_int(pad_before[ndim - 2], 0):
raise ValueError("Do not support pad on the innermost block")
if not util.equal_const_int(pad_after[ndim - 2], 0):
raise ValueError("Do not support pad on the innermost block")
y_pad_before = pad_before[0]
x_pad_before = pad_before[1]
y_pad_after = pad_after[0]
x_pad_after = pad_after[1]
allow_fold = False
else:
x_pad_before = 0
y_pad_before = 0
x_pad_after = 0
y_pad_after = 0
allow_fold = True
_check_compact(dst)
x_size, y_size, x_stride, offset = _get_2d_pattern(
src, elem_width, elem_bytes, data_type,
dst.scope, allow_fold=allow_fold)
irb = tvm.ir_builder.create()
irb.scope_attr(env.dev.vta_axis, "coproc_scope",
env.dev.get_task_qid(task_qid))
irb.emit(tvm.call_extern(
"int32", "VTALoadBuffer2D",
env.dev.command_handle,
src.data, offset, x_size, y_size, x_stride,
x_pad_before, y_pad_before,
x_pad_after, y_pad_after,
dst.access_ptr("r", "int32"), mem_type))
return irb.get()
else:
raise RuntimeError("Do not support copy %s->%s" % (src.scope, dst.scope))
return tvm.ir_pass.InjectCopyIntrin(stmt_in, "dma_copy", _inject_copy)
def annotate_alu_coproc_scope(stmt_in):
"""Pass to insert ALU instruction.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
env = get_env()
def _do_fold(stmt):
if _match_pragma(stmt, "alu"):
irb = tvm.ir_builder.create()
irb.scope_attr(env.dev.vta_axis, "coproc_scope",
env.dev.get_task_qid(env.dev.QID_COMPUTE))
irb.scope_attr(env.dev.vta_axis, "coproc_uop_scope",
tvm.make.StringImm("VTAPushALUOp"))
irb.emit(stmt)
return irb.get()
elif _match_pragma(stmt, "skip_alu"):
return tvm.make.Evaluate(0)
return stmt
stmt_out = tvm.ir_pass.IRTransform(
stmt_in, None, _do_fold, ["AttrStmt"])
return stmt_out
def inject_alu_intrin(stmt_in):
"""Pass to inject ALU micro-ops.
Parameters
----------
stmt_in : Stmt
Input statement
Returns
-------
stmt_out : Stmt
Transformed statement
"""
env = get_env()
def _do_fold(stmt):
def _equal(x, y):
return tvm.ir_pass.Equal(tvm.ir_pass.Simplify(x - y), 0)
def _flatten_loop(src_coeff, dst_coeff, extents):
src_coeff = list(src_coeff)
dst_coeff = list(dst_coeff)
extents = list(extents)
rev_src_coeff = [src_coeff.pop()]
rev_dst_coeff = [dst_coeff.pop()]
rev_extents = []
assert src_coeff
vsrc = src_coeff.pop()
vdst = dst_coeff.pop()
vext = extents.pop()
while src_coeff:
next_src = src_coeff.pop()
next_dst = dst_coeff.pop()
next_ext = extents.pop()
if _equal(next_src, vsrc * vext) and _equal(next_dst, vdst * vext):
vext = tvm.ir_pass.Simplify(vext * next_ext)
else:
rev_src_coeff.append(vsrc)
rev_dst_coeff.append(vdst)
rev_extents.append(vext)
vsrc = next_src
vdst = next_dst
vext = next_ext
rev_src_coeff.append(vsrc)
rev_dst_coeff.append(vdst)
rev_extents.append(vext)
rev_src_coeff.reverse()
rev_dst_coeff.reverse()
rev_extents.reverse()
return rev_src_coeff, rev_dst_coeff, rev_extents
if _match_pragma(stmt, "alu"):
# Get to the innermost loop body
loop_body = stmt.body
nest_size = 0
while isinstance(loop_body, tvm.stmt.For):
loop_body = loop_body.body
nest_size += 1
# Get the src/dst arguments
dst_var = loop_body.buffer_var
dst_idx = loop_body.index
# Derive loop variables and extents
tmp_body = stmt.body
indices = []
extents = []
for _ in range(nest_size):
indices.append(tmp_body.loop_var)
extents.append(tmp_body.extent)
tmp_body = tmp_body.body
# Derive opcode
if isinstance(loop_body.value, tvm.expr.Add):
alu_opcode = env.dev.ALU_OPCODE_ADD
lhs = loop_body.value.a
rhs = loop_body.value.b
elif isinstance(loop_body.value, tvm.expr.Sub):
alu_opcode = env.dev.ALU_OPCODE_SUB
lhs = loop_body.value.a
rhs = loop_body.value.b
elif isinstance(loop_body.value, tvm.expr.Mul):
alu_opcode = env.dev.ALU_OPCODE_MUL
lhs = loop_body.value.a
rhs = loop_body.value.b
elif isinstance(loop_body.value, tvm.expr.Min):
alu_opcode = env.dev.ALU_OPCODE_MIN
lhs = loop_body.value.a
rhs = loop_body.value.b
elif isinstance(loop_body.value, tvm.expr.Max):
alu_opcode = env.dev.ALU_OPCODE_MAX
lhs = loop_body.value.a
rhs = loop_body.value.b
elif isinstance(loop_body.value, tvm.expr.Call):
if loop_body.value.name == 'shift_left':
alu_opcode = env.dev.ALU_OPCODE_SHR
lhs = loop_body.value.args[0]
rhs = tvm.ir_pass.Simplify(-loop_body.value.args[1])
elif loop_body.value.name == 'shift_right':
alu_opcode = env.dev.ALU_OPCODE_SHR
lhs = loop_body.value.args[0]
rhs = loop_body.value.args[1]
else:
raise RuntimeError(
"Function call not recognized %s" % (loop_body.value.name))
elif isinstance(loop_body.value, tvm.expr.Load):
alu_opcode = env.dev.ALU_OPCODE_SHR
lhs = loop_body.value
rhs = tvm.const(0)
else:
raise RuntimeError(
"Expression not recognized %s, %s, %s" % (
type(loop_body.value), str(loop_body.value), str(stmt)))
# Derive array index coefficients
dst_coeff = tvm.arith.DetectLinearEquation(dst_idx, indices)
# Check if lhs/rhs is immediate
use_imm = False
imm_val = None
if isinstance(rhs, tvm.expr.IntImm):
assert lhs.buffer_var.same_as(dst_var)
src_coeff = tvm.arith.DetectLinearEquation(lhs.index, indices)
use_imm = True
imm_val = rhs
if isinstance(lhs, tvm.expr.IntImm):
assert rhs.buffer_var.same_as(dst_var)
src_coeff = tvm.arith.DetectLinearEquation(rhs.index, indices)
use_imm = True
imm_val = lhs
if imm_val is None:
imm_val = 0
assert lhs.buffer_var.same_as(dst_var) and rhs.buffer_var.same_as(dst_var)
src_lhs_coeff = tvm.arith.DetectLinearEquation(lhs.index, indices)
src_rhs_coeff = tvm.arith.DetectLinearEquation(rhs.index, indices)
# Determine which side has the same coefficients
lhs_equal = True
rhs_equal = True
for i, coef in enumerate(dst_coeff):
if not tvm.ir_pass.Equal(coef, src_lhs_coeff[i]):
lhs_equal = False
if not tvm.ir_pass.Equal(coef, src_rhs_coeff[i]):
rhs_equal = False
# Make sure at least one of the source is identical to the
# destination (in-place computation)
assert lhs_equal or rhs_equal
# Assign the source coefficients
if lhs_equal:
src_coeff = src_rhs_coeff
else:
src_coeff = src_lhs_coeff
# Ensure that we have the proper tensor dimensions in the
# innermost loop (pattern match)
src_coeff = list(src_coeff)
dst_coeff = list(dst_coeff)
extents = list(extents)
assert len(src_coeff) > 1
assert len(dst_coeff) > 1
assert len(extents) != 0
assert tvm.ir_pass.Equal(
tvm.ir_pass.Simplify(
src_coeff[-1] % (env.BATCH * env.BLOCK_OUT)), 0)
assert tvm.ir_pass.Equal(
tvm.ir_pass.Simplify(
dst_coeff[-1] % (env.BATCH * env.BLOCK_OUT)), 0)
assert tvm.ir_pass.Equal(src_coeff[-2], 1)
assert tvm.ir_pass.Equal(dst_coeff[-2], 1)
if env.BATCH > 1:
assert len(src_coeff) > 2
assert len(dst_coeff) > 2
assert len(extents) > 1
assert tvm.ir_pass.Equal(src_coeff[-3], env.BLOCK_OUT)
assert tvm.ir_pass.Equal(dst_coeff[-3], env.BLOCK_OUT)
# Apply tensorization of the loop coefficients
src_offset = src_coeff[-1]
dst_offset = dst_coeff[-1]
if env.BATCH == 1:
src_coeff = src_coeff[:-2]
dst_coeff = dst_coeff[:-2]
extents = extents[:-1]
else:
src_coeff = src_coeff[:-3]
dst_coeff = dst_coeff[:-3]
extents = extents[:-2]
src_coeff.append(src_offset)
dst_coeff.append(dst_offset)
src_coeff = [
tvm.ir_pass.Simplify(c // (env.BATCH * env.BLOCK_OUT)) for c in src_coeff]
dst_coeff = [
tvm.ir_pass.Simplify(c // (env.BATCH * env.BLOCK_OUT)) for c in dst_coeff]
# Flatten the outer loops
if extents:
src_coeff, dst_coeff, extents = _flatten_loop(src_coeff, dst_coeff, extents)
# Insert ALU micro-ops
irb = tvm.ir_builder.create()
for idx, extent in enumerate(extents):
irb.emit(tvm.call_extern(
"int32", "VTAUopLoopBegin",
extent, dst_coeff[idx], src_coeff[idx], 0))
use_imm = int(use_imm)
irb.emit(tvm.call_extern(
"int32", "VTAUopPush",
1, 0,
dst_coeff[len(dst_coeff)-1],
src_coeff[len(src_coeff)-1],
0,
alu_opcode, use_imm, imm_val))
for extent in extents:
irb.emit(tvm.call_extern(
"int32", "VTAUopLoopEnd"))
return irb.get()
return stmt
stmt_out = tvm.ir_pass.IRTransform(
stmt_in, None, _do_fold, ["AttrStmt"])
return stmt_out
def debug_print(stmt):
"""A debug pass that print the stmt
Parameters
----------
stmt : Stmt
The input statement
Returns
-------
stmt : Stmt
The
"""
# pylint: disable=superfluous-parens
print(stmt)
return stmt
| {
"repo_name": "mlperf/training_results_v0.6",
"path": "Fujitsu/benchmarks/resnet/implementations/mxnet/3rdparty/tvm/vta/python/vta/ir_pass.py",
"copies": "1",
"size": "30165",
"license": "apache-2.0",
"hash": -1532618107827082000,
"line_mean": 35.2996389892,
"line_max": 94,
"alpha_frac": 0.4978617603,
"autogenerated": false,
"ratio": 3.8358341810783316,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.48336959413783315,
"avg_score": null,
"num_lines": null
} |
""" Additional Jinja2 filters """
import os
import re
import sys
from jinja2 import is_undefined, contextfilter
from jinja2.exceptions import UndefinedError
if sys.version_info >= (3,0):
from shutil import which
elif sys.version_info >= (2,5):
from shutilwhich import which
else:
assert False, "Unsupported Python version: %s" % sys.version_info
if sys.version_info >= (3,3):
from shlex import quote as sh_quote
elif sys.version_info >= (2,7):
from pipes import quote as sh_quote
else:
assert False, "Unsupported Python version: %s" % sys.version_info
def docker_link(value, format='{addr}:{port}'):
""" Given a Docker Link environment variable value, format it into something else.
XXX: The name of the filter is not very informative. This is actually a partial URI parser.
This first parses a Docker Link value like this:
DB_PORT=tcp://172.17.0.5:5432
Into a dict:
```python
{
'proto': 'tcp',
'addr': '172.17.0.5',
'port': '5432'
}
```
And then uses `format` to format it, where the default format is '{addr}:{port}'.
More info here: [Docker Links](https://docs.docker.com/userguide/dockerlinks/)
:param value: Docker link (from an environment variable)
:param format: The format to apply. Supported placeholders: `{proto}`, `{addr}`, `{port}`
:return: Formatted string
"""
# pass undefined values on down the pipeline
if is_undefined(value):
return value
# Parse the value
m = re.match(r'(?P<proto>.+)://' r'(?P<addr>.+):' r'(?P<port>.+)$', value)
if not m:
raise ValueError('The provided value does not seems to be a Docker link: {0}'.format(value))
d = m.groupdict()
# Format
return format.format(**d)
def env(varname, default=None):
""" Use an environment variable's value inside your template.
This filter is available even when your data source is something other that the environment.
Example:
```jinja2
User: {{ user_login }}
Pass: {{ "USER_PASSWORD"|env }}
```
You can provide the default value:
```jinja2
Pass: {{ "USER_PASSWORD"|env("-none-") }}
```
For your convenience, it's also available as a function:
```jinja2
User: {{ user_login }}
Pass: {{ env("USER_PASSWORD") }}
```
Notice that there must be quotes around the environment variable name
"""
if default is not None:
# With the default, there's never an error
return os.getenv(varname, default)
else:
# Raise KeyError when not provided
return os.environ[varname]
def align_suffix(text, delim, column=None, spaces_after_delim=1):
""" Align the suffixes of lines in text, starting from the specified delim.
"""
s=''
if column is None or column == 'auto':
column = max(map(lambda l: l.find(delim), text.splitlines()))
elif column == 'previous':
column = align_suffix.column_previous
for l in map(lambda s: s.split(delim, 1), text.splitlines()):
if len(l) < 2:
# no delimiter occurs
s += l[0].rstrip() + os.linesep
elif l[0].strip() == '':
# no content before delimiter - leave as-is
s += l[0] + delim + l[1] + os.linesep
else:
# align
s += l[0].rstrip().ljust(column) + delim + spaces_after_delim*' ' + l[1].strip() + os.linesep
align_suffix.column_previous = column
return s
align_suffix.column_previous = None
@contextfilter
def ctxlookup(context, key):
""" Lookup the value of a key in the template context.
"""
v = context
try:
for k in key.split('.'):
v = v[k]
return v
except KeyError:
return context.environment.undefined(name=key)
def sh_opt(text, name, delim=" ", quote=False):
""" Format text as a command line option.
"""
if not text:
return ''
if quote:
text = sh_quote(text)
return '%s%s%s' % (name, delim, text)
def sh_optq(text, name, delim=" "):
""" Quote text and format as a command line option.
"""
return sh_opt(text, name, delim, quote=True)
# Filters to be loaded
EXTRA_FILTERS = {
'sh_quote': sh_quote,
'sh_which': which,
'sh_expand': lambda s: os.path.expandvars(os.path.expanduser(s)),
'sh_expanduser': os.path.expanduser,
'sh_expandvars': os.path.expandvars,
'sh_realpath': os.path.realpath,
'sh_opt': sh_opt,
'sh_optq': sh_optq,
'ifelse': lambda t, truev, falsev: truev if t else falsev,
'onoff': lambda t: 'on' if t else 'off',
'yesno': lambda t: 'yes' if t else 'no',
'docker_link': docker_link,
'env': env,
'align_suffix': align_suffix,
'ctxlookup': ctxlookup,
}
| {
"repo_name": "m000/j2cli",
"path": "j2cli/extras/filters.py",
"copies": "1",
"size": "4836",
"license": "bsd-2-clause",
"hash": -2902209838115560000,
"line_mean": 27.9580838323,
"line_max": 105,
"alpha_frac": 0.6048387097,
"autogenerated": false,
"ratio": 3.6775665399239545,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.47824052496239544,
"avg_score": null,
"num_lines": null
} |
"""Additional methods usable in with-context
"""
import contextlib
import os
import os.path as osp
import shutil
import sys
import tempfile
import timeit
import six
@contextlib.contextmanager
def capture_stdout():
"""Intercept standard output in a with-context
:return: cStringIO instance
>>> with capture_stdout() as stdout:
...
print stdout.getvalue()
"""
stdout = sys.stdout
sys.stdout = six.moves.cStringIO()
try:
yield sys.stdout
finally:
sys.stdout = stdout
@contextlib.contextmanager
def write_wherever(file_name=None):
writer = open(file_name, 'w') if file_name is not None else sys.stdout
yield writer
if file_name is not None:
writer.close()
@contextlib.contextmanager
def pushd(path, mkdir=True, cleanup=False):
"""Change current working directory in a with-context
:param mkdir: If True, then directory is created if it does not exist
:param cleanup: If True and no pre-existing directory, the directory is
cleaned up at the end
"""
cwd = os.getcwd()
exists = osp.exists(path)
if mkdir and not exists:
os.makedirs(path)
os.chdir(path)
try:
yield path
finally:
os.chdir(cwd)
if not exists and cleanup:
# NB: should we be checking for rmtree.avoids_symlink_attacks ?
shutil.rmtree(path)
class Timer(object): # pylint: disable=too-few-public-methods
"""Object usable in with-context to time it.
"""
def __init__(self):
self.start = None
self.end = None
self.timer = timeit.Timer()
def __call__(self):
return self.timer.timer()
def __enter__(self):
self.start = self()
return self
def __exit__(self, exc_type, exc_value, exc_traceback):
self.end = self()
@property
def elapsed(self):
"""
:return: duration in seconds spent in the context.
:rtype: float
"""
if self.end is None:
return self() - self.end
return self.end - self.start
@contextlib.contextmanager
def mkdtemp(*args, **kwargs):
"""Create a temporary directory in a with-context
keyword remove: Remove the directory when leaving the
context if True. Default is True.
other keywords arguments are given to the tempfile.mkdtemp
function.
"""
remove = kwargs.pop('remove', True)
path = tempfile.mkdtemp(*args, **kwargs)
try:
yield path
finally:
if remove:
shutil.rmtree(path)
@contextlib.contextmanager
def modified_environ(*remove, **update):
"""
Temporarily updates the ``os.environ`` dictionary in-place.
The ``os.environ`` dictionary is updated in-place so that the modification
is sure to work in all situations.
:param remove: Environment variables to remove.
:param update: Dictionary of environment variables
and values to add/update.
"""
env = os.environ
update = update or {}
remove = remove or []
# List of environment variables being updated or removed.
stomped = (set(update) | set(remove)) & set(env)
# Environment variables and values to restore on exit.
update_after = {k: env[k] for k in stomped}
# Environment variables and values to remove on exit.
remove_after = frozenset(k for k in update if k not in env)
try:
env.update(update)
[env.pop(k, None) for k in remove]
yield
finally:
env.update(update_after)
[env.pop(k) for k in remove_after]
| {
"repo_name": "tristan0x/hpcbench",
"path": "hpcbench/toolbox/contextlib_ext.py",
"copies": "1",
"size": "3572",
"license": "mit",
"hash": -1119679845580710000,
"line_mean": 25.0729927007,
"line_max": 78,
"alpha_frac": 0.6349384099,
"autogenerated": false,
"ratio": 4.0590909090909095,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0,
"num_lines": 137
} |
# Additional MySQL-specific tests
# Written by: F. Gabriel Gosselin <gabrielNOSPAM@evidens.ca>
# Based on tests by: aarranz
from south.tests import unittest
from south.db import db, generic, mysql
from django.db import connection, models
class TestMySQLOperations(unittest.TestCase):
"""MySQL-specific tests"""
def setUp(self):
db.debug = False
db.clear_deferred_sql()
def tearDown(self):
pass
def _create_foreign_tables(self, main_name, reference_name):
# Create foreign table and model
Foreign = db.mock_model(model_name='Foreign', db_table=reference_name,
db_tablespace='', pk_field_name='id',
pk_field_type=models.AutoField,
pk_field_args=[])
db.create_table(reference_name, [
('id', models.AutoField(primary_key=True)),
])
# Create table with foreign key
db.create_table(main_name, [
('id', models.AutoField(primary_key=True)),
('foreign', models.ForeignKey(Foreign)),
])
return Foreign
def test_constraint_references(self):
"""Tests that referred table is reported accurately"""
if db.backend_name != "mysql":
return
main_table = 'test_cns_ref'
reference_table = 'test_cr_foreign'
db.start_transaction()
self._create_foreign_tables(main_table, reference_table)
db.execute_deferred_sql()
constraint = db._find_foreign_constraints(main_table, 'foreign_id')[0]
constraint_name = 'foreign_id_refs_id_%x' % (abs(hash((main_table,
reference_table))))
self.assertEquals(constraint_name, constraint)
references = db._lookup_constraint_references(main_table, constraint)
self.assertEquals((reference_table, 'id'), references)
db.delete_table(main_table)
db.delete_table(reference_table)
def test_reverse_column_constraint(self):
"""Tests that referred column in a foreign key (ex. id) is found"""
if db.backend_name != "mysql":
return
main_table = 'test_reverse_ref'
reference_table = 'test_rr_foreign'
db.start_transaction()
self._create_foreign_tables(main_table, reference_table)
db.execute_deferred_sql()
inverse = db._lookup_reverse_constraint(reference_table, 'id')
(cname, rev_table, rev_column) = inverse[0]
self.assertEquals(main_table, rev_table)
self.assertEquals('foreign_id', rev_column)
db.delete_table(main_table)
db.delete_table(reference_table)
def test_delete_fk_column(self):
if db.backend_name != "mysql":
return
main_table = 'test_drop_foreign'
ref_table = 'test_df_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
db.delete_column(main_table, 'foreign_id')
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 0)
db.delete_table(main_table)
db.delete_table(ref_table)
def test_rename_fk_column(self):
if db.backend_name != "mysql":
return
main_table = 'test_rename_foreign'
ref_table = 'test_rf_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
db.rename_column(main_table, 'foreign_id', 'reference_id')
db.execute_deferred_sql() #Create constraints
constraints = db._find_foreign_constraints(main_table, 'reference_id')
self.assertEquals(len(constraints), 1)
db.delete_table(main_table)
db.delete_table(ref_table)
def test_rename_fk_inbound(self):
"""
Tests that the column referred to by an external column can be renamed.
Edge case, but also useful as stepping stone to renaming tables.
"""
if db.backend_name != "mysql":
return
main_table = 'test_rename_fk_inbound'
ref_table = 'test_rfi_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._lookup_reverse_constraint(ref_table, 'id')
self.assertEquals(len(constraints), 1)
db.rename_column(ref_table, 'id', 'rfi_id')
db.execute_deferred_sql() #Create constraints
constraints = db._lookup_reverse_constraint(ref_table, 'rfi_id')
self.assertEquals(len(constraints), 1)
cname = db._find_foreign_constraints(main_table, 'foreign_id')[0]
(rtable, rcolumn) = db._lookup_constraint_references(main_table, cname)
self.assertEquals(rcolumn, 'rfi_id')
db.delete_table(main_table)
db.delete_table(ref_table)
def test_rename_constrained_table(self):
"""Renames a table with a foreign key column (towards another table)"""
if db.backend_name != "mysql":
return
main_table = 'test_rn_table'
ref_table = 'test_rt_ref'
renamed_table = 'test_renamed_table'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
db.rename_table(main_table, renamed_table)
db.execute_deferred_sql() #Create constraints
constraints = db._find_foreign_constraints(renamed_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
(rtable, rcolumn) = db._lookup_constraint_references(
renamed_table, constraints[0])
self.assertEquals(rcolumn, 'id')
db.delete_table(renamed_table)
db.delete_table(ref_table)
def test_renamed_referenced_table(self):
"""Rename a table referred to in a foreign key"""
if db.backend_name != "mysql":
return
main_table = 'test_rn_refd_table'
ref_table = 'test_rrt_ref'
renamed_table = 'test_renamed_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._lookup_reverse_constraint(ref_table)
self.assertEquals(len(constraints), 1)
db.rename_table(ref_table, renamed_table)
db.execute_deferred_sql() #Create constraints
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
(rtable, rcolumn) = db._lookup_constraint_references(
main_table, constraints[0])
self.assertEquals(renamed_table, rtable)
db.delete_table(main_table)
db.delete_table(renamed_table)
| {
"repo_name": "cubicova17/annet",
"path": "venv/lib/python2.7/site-packages/south/tests/db_mysql.py",
"copies": "13",
"size": "7006",
"license": "mit",
"hash": 3030316746634474500,
"line_mean": 41.4606060606,
"line_max": 79,
"alpha_frac": 0.6216100485,
"autogenerated": false,
"ratio": 3.824235807860262,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.006690771349862259,
"num_lines": 165
} |
# Additional MySQL-specific tests
# Written by: F. Gabriel Gosselin <gabrielNOSPAM@evidens.ca>
# Based on tests by: aarranz
from south.tests import unittest, skipUnless
from south.db import db, generic, mysql
from django.db import connection, models
class TestMySQLOperations(unittest.TestCase):
"""MySQL-specific tests"""
# A class decoration may be used in lieu of this when Python 2.5 is the
# minimum.
def __metaclass__(name, bases, dict_):
decorator = skipUnless(db.backend_name == "mysql", 'MySQL-specific tests')
for key, method in dict_.iteritems():
if key.startswith('test'):
dict_[key] = decorator(method)
return type(name, bases, dict_)
def setUp(self):
db.debug = False
db.clear_deferred_sql()
def tearDown(self):
pass
def _create_foreign_tables(self, main_name, reference_name):
# Create foreign table and model
Foreign = db.mock_model(model_name='Foreign', db_table=reference_name,
db_tablespace='', pk_field_name='id',
pk_field_type=models.AutoField,
pk_field_args=[])
db.create_table(reference_name, [
('id', models.AutoField(primary_key=True)),
])
# Create table with foreign key
db.create_table(main_name, [
('id', models.AutoField(primary_key=True)),
('foreign', models.ForeignKey(Foreign)),
])
return Foreign
def test_constraint_references(self):
"""Tests that referred table is reported accurately"""
main_table = 'test_cns_ref'
reference_table = 'test_cr_foreign'
db.start_transaction()
self._create_foreign_tables(main_table, reference_table)
db.execute_deferred_sql()
constraint = db._find_foreign_constraints(main_table, 'foreign_id')[0]
constraint_name = 'foreign_id_refs_id_%x' % (abs(hash((main_table,
reference_table))))
self.assertEquals(constraint_name, constraint)
references = db._lookup_constraint_references(main_table, constraint)
self.assertEquals((reference_table, 'id'), references)
db.delete_table(main_table)
db.delete_table(reference_table)
def test_reverse_column_constraint(self):
"""Tests that referred column in a foreign key (ex. id) is found"""
main_table = 'test_reverse_ref'
reference_table = 'test_rr_foreign'
db.start_transaction()
self._create_foreign_tables(main_table, reference_table)
db.execute_deferred_sql()
inverse = db._lookup_reverse_constraint(reference_table, 'id')
(cname, rev_table, rev_column) = inverse[0]
self.assertEquals(main_table, rev_table)
self.assertEquals('foreign_id', rev_column)
db.delete_table(main_table)
db.delete_table(reference_table)
def test_delete_fk_column(self):
main_table = 'test_drop_foreign'
ref_table = 'test_df_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
db.delete_column(main_table, 'foreign_id')
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 0)
db.delete_table(main_table)
db.delete_table(ref_table)
def test_rename_fk_column(self):
main_table = 'test_rename_foreign'
ref_table = 'test_rf_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
db.rename_column(main_table, 'foreign_id', 'reference_id')
db.execute_deferred_sql() #Create constraints
constraints = db._find_foreign_constraints(main_table, 'reference_id')
self.assertEquals(len(constraints), 1)
db.delete_table(main_table)
db.delete_table(ref_table)
def test_rename_fk_inbound(self):
"""
Tests that the column referred to by an external column can be renamed.
Edge case, but also useful as stepping stone to renaming tables.
"""
main_table = 'test_rename_fk_inbound'
ref_table = 'test_rfi_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._lookup_reverse_constraint(ref_table, 'id')
self.assertEquals(len(constraints), 1)
db.rename_column(ref_table, 'id', 'rfi_id')
db.execute_deferred_sql() #Create constraints
constraints = db._lookup_reverse_constraint(ref_table, 'rfi_id')
self.assertEquals(len(constraints), 1)
cname = db._find_foreign_constraints(main_table, 'foreign_id')[0]
(rtable, rcolumn) = db._lookup_constraint_references(main_table, cname)
self.assertEquals(rcolumn, 'rfi_id')
db.delete_table(main_table)
db.delete_table(ref_table)
def test_rename_constrained_table(self):
"""Renames a table with a foreign key column (towards another table)"""
main_table = 'test_rn_table'
ref_table = 'test_rt_ref'
renamed_table = 'test_renamed_table'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
db.rename_table(main_table, renamed_table)
db.execute_deferred_sql() #Create constraints
constraints = db._find_foreign_constraints(renamed_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
(rtable, rcolumn) = db._lookup_constraint_references(
renamed_table, constraints[0])
self.assertEquals(rcolumn, 'id')
db.delete_table(renamed_table)
db.delete_table(ref_table)
def test_renamed_referenced_table(self):
"""Rename a table referred to in a foreign key"""
main_table = 'test_rn_refd_table'
ref_table = 'test_rrt_ref'
renamed_table = 'test_renamed_ref'
self._create_foreign_tables(main_table, ref_table)
db.execute_deferred_sql()
constraints = db._lookup_reverse_constraint(ref_table)
self.assertEquals(len(constraints), 1)
db.rename_table(ref_table, renamed_table)
db.execute_deferred_sql() #Create constraints
constraints = db._find_foreign_constraints(main_table, 'foreign_id')
self.assertEquals(len(constraints), 1)
(rtable, rcolumn) = db._lookup_constraint_references(
main_table, constraints[0])
self.assertEquals(renamed_table, rtable)
db.delete_table(main_table)
db.delete_table(renamed_table)
| {
"repo_name": "lmorchard/whuru",
"path": "vendor-local/src/south/south/tests/db_mysql.py",
"copies": "1",
"size": "7005",
"license": "bsd-3-clause",
"hash": -8867923128787148000,
"line_mean": 41.9754601227,
"line_max": 82,
"alpha_frac": 0.6302640971,
"autogenerated": false,
"ratio": 3.809135399673736,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4939399496773736,
"avg_score": null,
"num_lines": null
} |
"""Additional regular expression utilities, to make it easier to sync up
with Java regular expression code.
>>> import re
>>> from .re_util import fullmatch
>>> from .util import u
>>> string = 'abcd'
>>> r1 = re.compile('abcd')
>>> r2 = re.compile('bc')
>>> r3 = re.compile('abc')
>>> fullmatch(r1, string) # doctest: +ELLIPSIS
<...Match object...>
>>> fullmatch(r2, string)
>>> fullmatch(r3, string)
>>> r = re.compile(r'\\d{8}|\\d{10,11}')
>>> m = fullmatch(r, '1234567890')
>>> m.end()
10
>>> r = re.compile(u(r'[+\uff0b\\d]'), re.UNICODE)
>>> m = fullmatch(r, u('\uff10'))
>>> m.end()
1
"""
import re
def fullmatch(pattern, string, flags=0):
"""Try to apply the pattern at the start of the string, returning a match
object if the whole string matches, or None if no match was found."""
# Build a version of the pattern with a non-capturing group around it.
# This is needed to get m.end() to correctly report the size of the
# matched expression (as per the final doctest above).
grouped_pattern = re.compile("^(?:%s)$" % pattern.pattern, pattern.flags)
m = grouped_pattern.match(string)
if m and m.end() < len(string):
# Incomplete match (which should never happen because of the $ at the
# end of the regexp), treat as failure.
m = None # pragma no cover
return m
if __name__ == '__main__': # pragma no cover
import doctest
doctest.testmod()
| {
"repo_name": "daviddrysdale/python-phonenumbers",
"path": "python/phonenumbers/re_util.py",
"copies": "1",
"size": "1425",
"license": "apache-2.0",
"hash": -592040432917925200,
"line_mean": 31.3863636364,
"line_max": 77,
"alpha_frac": 0.6343859649,
"autogenerated": false,
"ratio": 3.3847980997624703,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.951918406466247,
"avg_score": 0,
"num_lines": 44
} |
"""Additional simple tables defined here."""
from terminaltables.ascii_table import AsciiTable
from terminaltables.terminal_io import IS_WINDOWS
class UnixTable(AsciiTable):
"""Draw a table using box-drawing characters on Unix platforms. Table borders won't have any gaps between lines.
Similar to the tables shown on PC BIOS boot messages, but not double-lined.
"""
CHAR_F_INNER_HORIZONTAL = '\033(0\x71\033(B'
CHAR_F_INNER_INTERSECT = '\033(0\x6e\033(B'
CHAR_F_INNER_VERTICAL = '\033(0\x78\033(B'
CHAR_F_OUTER_LEFT_INTERSECT = '\033(0\x74\033(B'
CHAR_F_OUTER_LEFT_VERTICAL = '\033(0\x78\033(B'
CHAR_F_OUTER_RIGHT_INTERSECT = '\033(0\x75\033(B'
CHAR_F_OUTER_RIGHT_VERTICAL = '\033(0\x78\033(B'
CHAR_H_INNER_HORIZONTAL = '\033(0\x71\033(B'
CHAR_H_INNER_INTERSECT = '\033(0\x6e\033(B'
CHAR_H_INNER_VERTICAL = '\033(0\x78\033(B'
CHAR_H_OUTER_LEFT_INTERSECT = '\033(0\x74\033(B'
CHAR_H_OUTER_LEFT_VERTICAL = '\033(0\x78\033(B'
CHAR_H_OUTER_RIGHT_INTERSECT = '\033(0\x75\033(B'
CHAR_H_OUTER_RIGHT_VERTICAL = '\033(0\x78\033(B'
CHAR_INNER_HORIZONTAL = '\033(0\x71\033(B'
CHAR_INNER_INTERSECT = '\033(0\x6e\033(B'
CHAR_INNER_VERTICAL = '\033(0\x78\033(B'
CHAR_OUTER_BOTTOM_HORIZONTAL = '\033(0\x71\033(B'
CHAR_OUTER_BOTTOM_INTERSECT = '\033(0\x76\033(B'
CHAR_OUTER_BOTTOM_LEFT = '\033(0\x6d\033(B'
CHAR_OUTER_BOTTOM_RIGHT = '\033(0\x6a\033(B'
CHAR_OUTER_LEFT_INTERSECT = '\033(0\x74\033(B'
CHAR_OUTER_LEFT_VERTICAL = '\033(0\x78\033(B'
CHAR_OUTER_RIGHT_INTERSECT = '\033(0\x75\033(B'
CHAR_OUTER_RIGHT_VERTICAL = '\033(0\x78\033(B'
CHAR_OUTER_TOP_HORIZONTAL = '\033(0\x71\033(B'
CHAR_OUTER_TOP_INTERSECT = '\033(0\x77\033(B'
CHAR_OUTER_TOP_LEFT = '\033(0\x6c\033(B'
CHAR_OUTER_TOP_RIGHT = '\033(0\x6b\033(B'
@property
def table(self):
"""Return a large string of the entire table ready to be printed to the terminal."""
ascii_table = super(UnixTable, self).table
optimized = ascii_table.replace('\033(B\033(0', '')
return optimized
class WindowsTable(AsciiTable):
"""Draw a table using box-drawing characters on Windows platforms. This uses Code Page 437. Single-line borders.
From: http://en.wikipedia.org/wiki/Code_page_437#Characters
"""
CHAR_F_INNER_HORIZONTAL = b'\xc4'.decode('ibm437')
CHAR_F_INNER_INTERSECT = b'\xc5'.decode('ibm437')
CHAR_F_INNER_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_F_OUTER_LEFT_INTERSECT = b'\xc3'.decode('ibm437')
CHAR_F_OUTER_LEFT_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_F_OUTER_RIGHT_INTERSECT = b'\xb4'.decode('ibm437')
CHAR_F_OUTER_RIGHT_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_H_INNER_HORIZONTAL = b'\xc4'.decode('ibm437')
CHAR_H_INNER_INTERSECT = b'\xc5'.decode('ibm437')
CHAR_H_INNER_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_H_OUTER_LEFT_INTERSECT = b'\xc3'.decode('ibm437')
CHAR_H_OUTER_LEFT_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_H_OUTER_RIGHT_INTERSECT = b'\xb4'.decode('ibm437')
CHAR_H_OUTER_RIGHT_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_INNER_HORIZONTAL = b'\xc4'.decode('ibm437')
CHAR_INNER_INTERSECT = b'\xc5'.decode('ibm437')
CHAR_INNER_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_OUTER_BOTTOM_HORIZONTAL = b'\xc4'.decode('ibm437')
CHAR_OUTER_BOTTOM_INTERSECT = b'\xc1'.decode('ibm437')
CHAR_OUTER_BOTTOM_LEFT = b'\xc0'.decode('ibm437')
CHAR_OUTER_BOTTOM_RIGHT = b'\xd9'.decode('ibm437')
CHAR_OUTER_LEFT_INTERSECT = b'\xc3'.decode('ibm437')
CHAR_OUTER_LEFT_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_OUTER_RIGHT_INTERSECT = b'\xb4'.decode('ibm437')
CHAR_OUTER_RIGHT_VERTICAL = b'\xb3'.decode('ibm437')
CHAR_OUTER_TOP_HORIZONTAL = b'\xc4'.decode('ibm437')
CHAR_OUTER_TOP_INTERSECT = b'\xc2'.decode('ibm437')
CHAR_OUTER_TOP_LEFT = b'\xda'.decode('ibm437')
CHAR_OUTER_TOP_RIGHT = b'\xbf'.decode('ibm437')
class WindowsTableDouble(AsciiTable):
"""Draw a table using box-drawing characters on Windows platforms. This uses Code Page 437. Double-line borders."""
CHAR_F_INNER_HORIZONTAL = b'\xcd'.decode('ibm437')
CHAR_F_INNER_INTERSECT = b'\xce'.decode('ibm437')
CHAR_F_INNER_VERTICAL = b'\xba'.decode('ibm437')
CHAR_F_OUTER_LEFT_INTERSECT = b'\xcc'.decode('ibm437')
CHAR_F_OUTER_LEFT_VERTICAL = b'\xba'.decode('ibm437')
CHAR_F_OUTER_RIGHT_INTERSECT = b'\xb9'.decode('ibm437')
CHAR_F_OUTER_RIGHT_VERTICAL = b'\xba'.decode('ibm437')
CHAR_H_INNER_HORIZONTAL = b'\xcd'.decode('ibm437')
CHAR_H_INNER_INTERSECT = b'\xce'.decode('ibm437')
CHAR_H_INNER_VERTICAL = b'\xba'.decode('ibm437')
CHAR_H_OUTER_LEFT_INTERSECT = b'\xcc'.decode('ibm437')
CHAR_H_OUTER_LEFT_VERTICAL = b'\xba'.decode('ibm437')
CHAR_H_OUTER_RIGHT_INTERSECT = b'\xb9'.decode('ibm437')
CHAR_H_OUTER_RIGHT_VERTICAL = b'\xba'.decode('ibm437')
CHAR_INNER_HORIZONTAL = b'\xcd'.decode('ibm437')
CHAR_INNER_INTERSECT = b'\xce'.decode('ibm437')
CHAR_INNER_VERTICAL = b'\xba'.decode('ibm437')
CHAR_OUTER_BOTTOM_HORIZONTAL = b'\xcd'.decode('ibm437')
CHAR_OUTER_BOTTOM_INTERSECT = b'\xca'.decode('ibm437')
CHAR_OUTER_BOTTOM_LEFT = b'\xc8'.decode('ibm437')
CHAR_OUTER_BOTTOM_RIGHT = b'\xbc'.decode('ibm437')
CHAR_OUTER_LEFT_INTERSECT = b'\xcc'.decode('ibm437')
CHAR_OUTER_LEFT_VERTICAL = b'\xba'.decode('ibm437')
CHAR_OUTER_RIGHT_INTERSECT = b'\xb9'.decode('ibm437')
CHAR_OUTER_RIGHT_VERTICAL = b'\xba'.decode('ibm437')
CHAR_OUTER_TOP_HORIZONTAL = b'\xcd'.decode('ibm437')
CHAR_OUTER_TOP_INTERSECT = b'\xcb'.decode('ibm437')
CHAR_OUTER_TOP_LEFT = b'\xc9'.decode('ibm437')
CHAR_OUTER_TOP_RIGHT = b'\xbb'.decode('ibm437')
class SingleTable(WindowsTable if IS_WINDOWS else UnixTable):
"""Cross-platform table with single-line box-drawing characters.
:ivar iter table_data: List (empty or list of lists of strings) representing the table.
:ivar str title: Optional title to show within the top border of the table.
:ivar bool inner_column_border: Separates columns.
:ivar bool inner_footing_row_border: Show a border before the last row.
:ivar bool inner_heading_row_border: Show a border after the first row.
:ivar bool inner_row_border: Show a border in between every row.
:ivar bool outer_border: Show the top, left, right, and bottom border.
:ivar dict justify_columns: Horizontal justification. Keys are column indexes (int). Values are right/left/center.
:ivar int padding_left: Number of spaces to pad on the left side of every cell.
:ivar int padding_right: Number of spaces to pad on the right side of every cell.
"""
pass
class DoubleTable(WindowsTableDouble):
"""Cross-platform table with box-drawing characters. On Windows it's double borders, on Linux/OSX it's unicode.
:ivar iter table_data: List (empty or list of lists of strings) representing the table.
:ivar str title: Optional title to show within the top border of the table.
:ivar bool inner_column_border: Separates columns.
:ivar bool inner_footing_row_border: Show a border before the last row.
:ivar bool inner_heading_row_border: Show a border after the first row.
:ivar bool inner_row_border: Show a border in between every row.
:ivar bool outer_border: Show the top, left, right, and bottom border.
:ivar dict justify_columns: Horizontal justification. Keys are column indexes (int). Values are right/left/center.
:ivar int padding_left: Number of spaces to pad on the left side of every cell.
:ivar int padding_right: Number of spaces to pad on the right side of every cell.
"""
pass
class PorcelainTable(AsciiTable):
"""An AsciiTable stripped to a minimum.
Meant to be machine passable and roughly follow format set by git --porcelain option (hence the name).
:ivar iter table_data: List (empty or list of lists of strings) representing the table.
"""
def __init__(self, table_data):
"""Constructor.
:param iter table_data: List (empty or list of lists of strings) representing the table.
"""
# Porcelain table won't support title since it has no outer birders.
super(PorcelainTable, self).__init__(table_data)
# Removes outer border, and inner footing and header row borders.
self.inner_footing_row_border = False
self.inner_heading_row_border = False
self.outer_border = False
| {
"repo_name": "Robpol86/terminaltables",
"path": "terminaltables/other_tables.py",
"copies": "3",
"size": "8480",
"license": "mit",
"hash": 679205521949493400,
"line_mean": 46.9096045198,
"line_max": 119,
"alpha_frac": 0.6795990566,
"autogenerated": false,
"ratio": 3.087004004368402,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0009092460853212792,
"num_lines": 177
} |
"""Additional test images.
For more images, see
- http://sipi.usc.edu/database/database.php
"""
import numpy as np
from scipy import ndimage
from skimage.io import imread
import os.path as _osp
data_dir = _osp.abspath(_osp.dirname(__file__)) + "/data"
def load(f):
"""Load an image file located in the data directory.
Parameters
----------
f : string
File name.
Returns
-------
img : ndarray
Image loaded from skimage.data_dir.
"""
return imread(_osp.join(data_dir, f))
def stinkbug():
"""24-bit RGB PNG image of a stink bug
Notes
-----
This image was downloaded from Matplotlib tutorial
<http://matplotlib.org/users/image_tutorial.html>
No known copyright restrictions, released into the public domain.
"""
return load("stinkbug.png")
def nuclei():
"""Gray-level "cell nuclei" image used for blob processing.
Notes
-----
This image was downloaded from Pythonvision Basic Tutorial
<http://pythonvision.org/media/files/images/dna.jpeg>
No known copyright restrictions, released into the public domain.
"""
return load("nuclei.png")
def baboon():
"""Baboon.
Notes
-----
This image was downloaded from the Signal and Image Processing Institute at the
University of Southern California.
<http://sipi.usc.edu/database/database.php?volume=misc&image=11#top>
No known copyright restrictions, released into the public domain.
"""
return load("baboon.png")
def city_depth():
"""City depth map.
Notes
-----
No known copyright restrictions, released into the public domain.
"""
return load("city_depth.png")
def city():
"""City.
Notes
-----
This image was generate form the Earthmine datas set of Perth, Australia.
This image is copyright earthmine.
"""
return load("city.png")
def aerial():
"""Aerial Sna Diego (shelter Island).
Notes
-----
This image was downloaded from the Signal and Image Processing Institute at the
University of Southern California.
<http://sipi.usc.edu/database/database.php?volume=aerials&image=10#top>
No known copyright restrictions, released into the public domain.
"""
return load("aerial.png")
def peppers():
"""Peppers.
Notes
-----
This image was downloaded from the Signal and Image Processing Institute at the
University of Southern California.
<http://sipi.usc.edu/database/database.php?volume=misc&image=11#top>
No known copyright restrictions, released into the public domain.
"""
return load("peppers.png")
def sign():
"""Sign.
"""
return load("sign.png")
def microstructure(l=256):
"""Synthetic binary data: binary microstructure with blobs.
Parameters
----------
l: int, optional
linear size of the returned image
Code fragment from scikit-image Medial axis skeletonization see:
<http://scikit-image.org/docs/dev/auto_examples/plot_medial_transform.html>
No known copyright restrictions, released into the public domain.
"""
n = 5
x, y = np.ogrid[0:l, 0:l]
mask = np.zeros((l, l))
generator = np.random.RandomState(1)
points = l * generator.rand(2, n ** 2)
mask[(points[0]).astype(np.int), (points[1]).astype(np.int)] = 1
mask = ndimage.gaussian_filter(mask, sigma=l / (4. * n))
return mask
def noisy_blobs(noise=True):
"""Synthetic binary data: four circles with noise.
Parameters
----------
noise: boolean, optional
include noise in image
Code fragment from 'Image manipulation and processing using Numpy and Scipy'
<http://www.tp.umu.se/~nylen/fnm/pylect/advanced/image_processing/index.html>
No known copyright restrictions, released into the public domain.
"""
np.random.seed(1)
n = 10
l = 256
blob = np.zeros((l, l))
points = l * np.random.random((2, n ** 2))
blob[(points[0]).astype(np.int), (points[1]).astype(np.int)] = 1
blob = ndimage.gaussian_filter(blob, sigma=l / (4. * n))
if noise:
mask = (blob > blob.mean()).astype(np.float)
mask += 0.1 * blob
blob = mask + 0.2 * np.random.randn(*mask.shape)
return blob
def noisy_circles(noise=True):
"""Synthetic binary data: four circles with noise.
Parameters
----------
noise: boolean, optional
include noise in image
Code fragment from 'Image manipulation and processing using Numpy and Scipy'
<http://www.tp.umu.se/~nylen/fnm/pylect/advanced/image_processing/index.html>
No known copyright restrictions, released into the public domain.
"""
l = 100
x, y = np.indices((l, l))
center1 = (28, 24)
center2 = (40, 50)
center3 = (67, 58)
center4 = (24, 70)
radius1, radius2, radius3, radius4 = 16, 14, 15, 14
circle1 = (x - center1[0]) ** 2 + (y - center1[1]) ** 2 < radius1 ** 2
circle2 = (x - center2[0]) ** 2 + (y - center2[1]) ** 2 < radius2 ** 2
circle3 = (x - center3[0]) ** 2 + (y - center3[1]) ** 2 < radius3 ** 2
circle4 = (x - center4[0]) ** 2 + (y - center4[1]) ** 2 < radius4 ** 2
# 4 circles
image = circle1 + circle2 + circle3 + circle4
if noise:
image = image.astype(float)
image += 1 + 0.2 * np.random.randn(*image.shape)
return image
def noisy_square(noise=True):
"""Synthetic binary data: square with noise.
Parameters
----------
noise: boolean, optional
include noise in image
Code fragment from scikit-image 'Canny edge detector'. see:
<http://scikit-image.org/docs/dev/auto_examples/plot_canny.html>
Also in 'Image manipulation and processing using Numpy and Scipy'
<http://www.tp.umu.se/~nylen/fnm/pylect/advanced/image_processing/index.html>
No known copyright restrictions, released into the public domain.
"""
# Generate noisy image of a square
im = np.zeros((128, 128))
im[32:-32, 32:-32] = 1
im = ndimage.rotate(im, 15, mode='constant')
im = ndimage.gaussian_filter(im, 4)
im += 0.2 * np.random.random(im.shape)
if noise:
im = im.astype(float)
im += 0.2 * np.random.random(im.shape)
return im
def mri():
"""MRI.
Notes
-----
This image was created/downloaded from the Matplotlib using the following:
dfile= cbook.get_sample_data('s1045.ima', asfileobj=False)
im = np.fromstring(file(dfile, 'rb').read(), np.uint16).astype(float)
im.shape = 256, 256
im2 = im.astype(float)/float(im.max())
imsave('mri.png',im2)
Code frament from 'pylab_examples example code: mri_with_eeg.py'
<http://matplotlib.org/examples/pylab_examples/mri_with_eeg.html>
No known copyright restrictions, released into the public domain.
"""
return load("mri.png")
def cells():
"""Cells
From in 'Image manipulation and processing using Numpy and Scipy' section
2.6.6 Measuring object properties
<http://www.tp.umu.se/~nylen/fnm/pylect/advanced/image_processing/index.html>
No known copyright restrictions, released into the public domain.
"""
np.random.seed(1)
n = 10
l = 256
im = np.zeros((l, l))
points = l * np.random.random((2, n ** 2))
im[(points[0]).astype(np.int), (points[1]).astype(np.int)] = 1
im = ndimage.gaussian_filter(im, sigma=l / (4. * n))
return im
def cross():
"""Synthetic binary data showing a cross
Code fragment from scikit-image:
<http://scikit-image.org/docs/dev/auto_examples/plot_hough_transform.html#example-plot-hough-transform-py>
No known copyright restrictions, released into the public domain.
"""
image = np.zeros((100, 100))
idx = np.arange(25, 75)
image[idx[::-1], idx] = 255
image[idx, idx] = 255
return image
def misc():
"""Synthetic binary data
Code fragment from scikit-image:
<http://scikit-image.org/docs/0.7.0/api/skimage.transform.hough_transform.html>
No known copyright restrictions, released into the public domain.
"""
image = np.zeros((100, 150), dtype=bool)
image[30, :] = 1
image[:, 65] = 1
image[35:45, 35:50] = 1
for i in range(90):
image[i, i] = 1
image += np.random.random(image.shape) > 0.95
return image
def random(same=False):
"""Synthetic binary data
Released into the public domain.
"""
# Generate standardized random data
if same:
np.random.seed(seed=1234)
else:
np.random.seed()
return np.random.randint(0, 255, size=(256, 256))
def overlapping_circles():
"""Synthetic binary data
Generate a binary image with two overlapping circles
Released into the public domain.
"""
x, y = np.indices((80, 80))
x1, y1, x2, y2 = 28, 28, 44, 52
r1, r2 = 16, 20
mask_circle1 = (x - x1) ** 2 + (y - y1) ** 2 < r1 ** 2
mask_circle2 = (x - x2) ** 2 + (y - y2) ** 2 < r2 ** 2
image = np.logical_or(mask_circle1, mask_circle2)
return image
| {
"repo_name": "michaelborck/ipfe",
"path": "ipfe/data.py",
"copies": "1",
"size": "9042",
"license": "bsd-3-clause",
"hash": 381209431492486000,
"line_mean": 23.5706521739,
"line_max": 110,
"alpha_frac": 0.6280690113,
"autogenerated": false,
"ratio": 3.41981845688351,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.454788746818351,
"avg_score": null,
"num_lines": null
} |
""" Additional TileStache cache providers.
"""
import os
from os.path import exists
import hashlib
from wsgiref.headers import Headers
from TileStache.Core import TheTileLeftANote
from TileStache.Caches import Disk
class SparseCache(Disk):
""" Disk cache which 404s "empty" tiles.
"""
def __init__(self, empty_size=334, **kwargs):
""" Initialize the SparseCache
334 is the file size of a 256x256 transparent PNG
"""
# TODO support multiple sizes
self.empty_size = empty_size
return Disk.__init__(self, **kwargs)
def read(self, layer, coord, format):
""" Read a cached tile.
"""
fullpath = self._fullpath(layer, coord, format)
if not exists(fullpath):
return None
if os.stat(fullpath).st_size == self.empty_size:
raise TheTileLeftANote(status_code=404, emit_content_type=False)
return Disk.read(self, layer, coord, format)
class LayerStub:
""" A Layer-like substance with enough depth for Disk.read()
"""
def __init__(self, name):
self.cache_lifespan = None
self._name = name
def name(self):
return self._name
class LanternCache(Disk):
""" Disk cache which appends metadata about the content of a tile.
"""
def __init__(self, land='', sea='', second=None, **kwargs):
self.land_md5 = land
self.sea_md5 = sea
self.second = LayerStub(second)
return Disk.__init__(self, **kwargs)
def md5sum(self, body):
if body:
m = hashlib.md5()
m.update(body)
return m.hexdigest()
def signal_land_or_sea(self, body, layer, coord, format):
if body:
md5sum = self.md5sum(body)
second_md5sum = self.md5sum(Disk.read(self, self.second, coord, format))
headers = Headers([('Access-Control-Expose-Headers', 'X-Land-Or-Sea')])
headers.setdefault('X-Land-Or-Sea', '0')
if second_md5sum and md5sum == second_md5sum:
if md5sum == self.land_md5:
headers['X-Land-Or-Sea'] = '1'
elif md5sum == self.sea_md5:
headers['X-Land-Or-Sea'] = '2'
raise TheTileLeftANote(content=body, headers=headers)
def read(self, layer, coord, format):
body = Disk.read(self, layer, coord, format)
self.signal_land_or_sea(body, layer, coord, format)
# we should never get here
return body
def save(self, body, layer, coord, format):
Disk.save(self, body, layer, coord, format)
self.signal_land_or_sea(body, layer, coord, format)
| {
"repo_name": "stamen/tilestache-goodies",
"path": "stamen/__init__.py",
"copies": "1",
"size": "2724",
"license": "bsd-3-clause",
"hash": 3941888326459323000,
"line_mean": 25.9702970297,
"line_max": 84,
"alpha_frac": 0.580763583,
"autogenerated": false,
"ratio": 3.721311475409836,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4802075058409836,
"avg_score": null,
"num_lines": null
} |
'Additional tools'
# Authors: Afshine Amidi <lastname@mit.edu>
# Shervine Amidi <firstname@stanford.edu>
# MIT License
import csv
import threading
csv.field_size_limit(10**7)
def read_dict(path):
'Reads Python dictionary stored in a csv file'
dictionary = {}
for key, val in csv.reader(open(path)):
dictionary[key] = val
return dictionary
def dict_to_csv(dictionary, path):
'Saves Python dictionary to a csv file'
w = csv.writer(open(path, 'w'))
for key, val in dictionary.items():
w.writerow([key, val])
def scale_dict(dictionary):
'Scales values of a dictionary'
maxi = max(map(abs, dictionary.values())) # Max in absolute value
return {k: v/maxi for k, v in dictionary.items()}
def get_class_weights(dictionary, training_enzymes, mode):
'Gets class weights for Keras'
# Initialization
counter = [0 for i in range(6)]
# Count classes
for enzyme in training_enzymes:
counter[int(dictionary[enzyme])-1] += 1
majority = max(counter)
# Make dictionary
class_weights = {i: float(majority/count) for i, count in enumerate(counter)}
# Value according to mode
if mode == 'unbalanced':
for key in class_weights:
class_weights[key] = 1
elif mode == 'balanced':
pass
elif mode == 'mean_1_balanced':
for key in class_weights:
class_weights[key] = (1+class_weights[key])/2
return class_weights
| {
"repo_name": "shervinea/enzynet",
"path": "enzynet/tools.py",
"copies": "1",
"size": "1469",
"license": "mit",
"hash": 7166020229225057000,
"line_mean": 25.7090909091,
"line_max": 81,
"alpha_frac": 0.6439754935,
"autogenerated": false,
"ratio": 3.489311163895487,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9619165316424207,
"avg_score": 0.0028242681942557924,
"num_lines": 55
} |
"""Additional utilities"""
import numpy as np
from ..coreDataContainers import Variable
def generateRandomVariable(shape, transpose=False, nInputs=1):
"""Generate a ga.Variable of a given shape filled with random values
from a Gaussian distribution with mean 0.
If the transpose flag is set, generate a Variable that is the transpose of a
given shape
Parameters
----------
shape : tuple
Shape of the desired variable
transpose : bool
If true, generate ga.Transposed variable with the shape being shape.T
nInputs : int
number of inputs for the variable
Returns
-------
ga.Variable
generated random variable
"""
reduction = 2 * np.sqrt(nInputs)
# print("Initiazing with reduction", reduction, "and shape", shape)
X = np.random.random(shape) / reduction
if (transpose):
return Variable(X.T)
else:
return Variable(X)
def generateZeroVariable(shape, transpose=False):
"""Generate a ga.Variable of a given shape filled with zeros
Parameters
----------
shape : tuple
Shape of the desired variable
transpose : bool
If true, generate ga.Transposed variable with the shape being shape.T
Returns
-------
ga.Variable
generated random variable
"""
X = np.zeros(shape)
if (transpose):
return Variable(X.T)
else:
return Variable(X)
def generateLinspaceVariable(shape, transpose=False, nInputs=None):
"""Generate a ga.Variable of a given shape filled with values from 0 to size
If the transpose flag is set, generate a Variable that is the transpose of a
given shape
Parameters
----------
shape : tuple
Shape of the desired variable
transpose : bool
If true, generate ga.Transposed variable with the shape being shape.T
nInputs : int
number of inputs for the variable
Returns
-------
ga.Variable
generated random variable
"""
X = np.zeros(shape)
X = np.arange(X.size).reshape(shape)
if (transpose):
return Variable(X.T)
else:
return Variable(X)
def calculateAccuracy(graph, data, labels):
"""Feed data to a graph, ask it for predictions and obtain accuracy
Parameters
----------
graph : ga.Graph
calculation graph
data : np.array
Input data
labels : np.array
labels for the data
Returns
-------
float
accuracy as a number from 0 to 1
"""
graph.resetAll()
graph.feederOperation.assignData(data)
preds = graph.makePredictions()
if np.size(labels.shape) == 1:
nExamples = 1
else:
nExamples = labels.shape[0]
error = np.sum(np.abs(preds - labels)) / (2 * nExamples)
return 1 - error
| {
"repo_name": "jgolebiowski/graphAttack",
"path": "graphAttack/gaUtilities/misc.py",
"copies": "1",
"size": "2823",
"license": "mit",
"hash": 4774768542845561000,
"line_mean": 23.1282051282,
"line_max": 80,
"alpha_frac": 0.6291179596,
"autogenerated": false,
"ratio": 4.397196261682243,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.00031655587211142766,
"num_lines": 117
} |
# ./additional_xml.py
# -*- coding: utf-8 -*-
# PyXB bindings for NM:e92452c8d3e28a9e27abfc9994d2007779e7f4c9
# Generated 2018-02-11 21:12:19.981503 by PyXB version 1.2.6 using Python 3.6.3.final.0
# Namespace AbsentNamespace0
from __future__ import unicode_literals
import pyxb
import pyxb.binding
import pyxb.binding.saxer
import io
import pyxb.utils.utility
import pyxb.utils.domutils
import sys
import pyxb.utils.six as _six
# Unique identifier for bindings created at the same time
_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:26475074-0f9a-11e8-bec7-186590d9922f')
# Version of PyXB used to generate the bindings
_PyXBVersion = '1.2.6'
# Generated bindings are not compatible across PyXB versions
if pyxb.__version__ != _PyXBVersion:
raise pyxb.PyXBVersionError(_PyXBVersion)
# A holder for module-level binding classes so we can access them from
# inside class definitions where property names may conflict.
_module_typeBindings = pyxb.utils.utility.Object()
# Import bindings for namespaces imported into schema
import pyxb.binding.datatypes
# NOTE: All namespace declarations are reserved within the binding
Namespace = pyxb.namespace.CreateAbsentNamespace()
Namespace.configureCategories(['typeBinding', 'elementBinding'])
def CreateFromDocument (xml_text, default_namespace=None, location_base=None):
"""Parse the given XML and use the document element to create a
Python instance.
@param xml_text An XML document. This should be data (Python 2
str or Python 3 bytes), or a text (Python 2 unicode or Python 3
str) in the L{pyxb._InputEncoding} encoding.
@keyword default_namespace The L{pyxb.Namespace} instance to use as the
default namespace where there is no default namespace in scope.
If unspecified or C{None}, the namespace of the module containing
this function will be used.
@keyword location_base: An object to be recorded as the base of all
L{pyxb.utils.utility.Location} instances associated with events and
objects handled by the parser. You might pass the URI from which
the document was obtained.
"""
if pyxb.XMLStyle_saxer != pyxb._XMLStyle:
dom = pyxb.utils.domutils.StringToDOM(xml_text)
return CreateFromDOM(dom.documentElement, default_namespace=default_namespace)
if default_namespace is None:
default_namespace = Namespace.fallbackNamespace()
saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base)
handler = saxer.getContentHandler()
xmld = xml_text
if isinstance(xmld, _six.text_type):
xmld = xmld.encode(pyxb._InputEncoding)
saxer.parse(io.BytesIO(xmld))
instance = handler.rootObject()
return instance
def CreateFromDOM (node, default_namespace=None):
"""Create a Python instance from the given DOM node.
The node tag must correspond to an element declaration in this module.
@deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}."""
if default_namespace is None:
default_namespace = Namespace.fallbackNamespace()
return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace)
# Atomic simple type: [anonymous]
class STD_ANON (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 121, 12)
_Documentation = None
STD_ANON._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON, enum_prefix=None)
STD_ANON.emissions = STD_ANON._CF_enumeration.addEnumeration(unicode_value='emissions', tag='emissions')
STD_ANON.hbefa = STD_ANON._CF_enumeration.addEnumeration(unicode_value='hbefa', tag='hbefa')
STD_ANON.harmonoise = STD_ANON._CF_enumeration.addEnumeration(unicode_value='harmonoise', tag='harmonoise')
STD_ANON.amitran = STD_ANON._CF_enumeration.addEnumeration(unicode_value='amitran', tag='amitran')
STD_ANON._InitializeFacetMap(STD_ANON._CF_enumeration)
_module_typeBindings.STD_ANON = STD_ANON
# Atomic simple type: [anonymous]
class STD_ANON_ (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 138, 20)
_Documentation = None
STD_ANON_._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_, enum_prefix=None)
STD_ANON_.defaults = STD_ANON_._CF_enumeration.addEnumeration(unicode_value='defaults', tag='defaults')
STD_ANON_._InitializeFacetMap(STD_ANON_._CF_enumeration)
_module_typeBindings.STD_ANON_ = STD_ANON_
# Atomic simple type: [anonymous]
class STD_ANON_2 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 153, 12)
_Documentation = None
STD_ANON_2._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_2, enum_prefix=None)
STD_ANON_2.SaveTLSStates = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='SaveTLSStates', tag='SaveTLSStates')
STD_ANON_2.SaveTLSSwitchTimes = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='SaveTLSSwitchTimes', tag='SaveTLSSwitchTimes')
STD_ANON_2.SaveTLSSwitchStates = STD_ANON_2._CF_enumeration.addEnumeration(unicode_value='SaveTLSSwitchStates', tag='SaveTLSSwitchStates')
STD_ANON_2._InitializeFacetMap(STD_ANON_2._CF_enumeration)
_module_typeBindings.STD_ANON_2 = STD_ANON_2
# Atomic simple type: positiveFloatType
class positiveFloatType (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'positiveFloatType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 10, 4)
_Documentation = None
positiveFloatType._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value_datatype=pyxb.binding.datatypes.float, value=pyxb.binding.datatypes._fp(0.0))
positiveFloatType._InitializeFacetMap(positiveFloatType._CF_minExclusive)
Namespace.addCategoryObject('typeBinding', 'positiveFloatType', positiveFloatType)
_module_typeBindings.positiveFloatType = positiveFloatType
# Atomic simple type: nonNegativeFloatType
class nonNegativeFloatType (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'nonNegativeFloatType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 16, 4)
_Documentation = None
nonNegativeFloatType._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=nonNegativeFloatType, value=pyxb.binding.datatypes.float(0.0))
nonNegativeFloatType._InitializeFacetMap(nonNegativeFloatType._CF_minInclusive)
Namespace.addCategoryObject('typeBinding', 'nonNegativeFloatType', nonNegativeFloatType)
_module_typeBindings.nonNegativeFloatType = nonNegativeFloatType
# Atomic simple type: [anonymous]
class STD_ANON_3 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 24, 12)
_Documentation = None
STD_ANON_3._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_3, value=pyxb.binding.datatypes.float(-1.0))
STD_ANON_3._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_3, value=pyxb.binding.datatypes.float(-1.0))
STD_ANON_3._InitializeFacetMap(STD_ANON_3._CF_minInclusive,
STD_ANON_3._CF_maxInclusive)
_module_typeBindings.STD_ANON_3 = STD_ANON_3
# Atomic simple type: [anonymous]
class STD_ANON_4 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 35, 12)
_Documentation = None
STD_ANON_4._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_4._CF_pattern.addPattern(pattern='(norm|normc)\\((\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+)))?)?\\)')
STD_ANON_4._InitializeFacetMap(STD_ANON_4._CF_pattern)
_module_typeBindings.STD_ANON_4 = STD_ANON_4
# Atomic simple type: positiveIntType
class positiveIntType (pyxb.binding.datatypes.int):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'positiveIntType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 43, 4)
_Documentation = None
positiveIntType._CF_minExclusive = pyxb.binding.facets.CF_minExclusive(value_datatype=pyxb.binding.datatypes.int, value=pyxb.binding.datatypes.long(0))
positiveIntType._InitializeFacetMap(positiveIntType._CF_minExclusive)
Namespace.addCategoryObject('typeBinding', 'positiveIntType', positiveIntType)
_module_typeBindings.positiveIntType = positiveIntType
# Atomic simple type: nonNegativeIntType
class nonNegativeIntType (pyxb.binding.datatypes.int):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'nonNegativeIntType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 49, 4)
_Documentation = None
nonNegativeIntType._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=nonNegativeIntType, value=pyxb.binding.datatypes.int(0))
nonNegativeIntType._InitializeFacetMap(nonNegativeIntType._CF_minInclusive)
Namespace.addCategoryObject('typeBinding', 'nonNegativeIntType', nonNegativeIntType)
_module_typeBindings.nonNegativeIntType = nonNegativeIntType
# Atomic simple type: boolType
class boolType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'boolType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 55, 4)
_Documentation = None
boolType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=boolType, enum_prefix=None)
boolType.true = boolType._CF_enumeration.addEnumeration(unicode_value='true', tag='true')
boolType.false = boolType._CF_enumeration.addEnumeration(unicode_value='false', tag='false')
boolType.True_ = boolType._CF_enumeration.addEnumeration(unicode_value='True', tag='True_')
boolType.False_ = boolType._CF_enumeration.addEnumeration(unicode_value='False', tag='False_')
boolType.yes = boolType._CF_enumeration.addEnumeration(unicode_value='yes', tag='yes')
boolType.no = boolType._CF_enumeration.addEnumeration(unicode_value='no', tag='no')
boolType.on = boolType._CF_enumeration.addEnumeration(unicode_value='on', tag='on')
boolType.off = boolType._CF_enumeration.addEnumeration(unicode_value='off', tag='off')
boolType.n1 = boolType._CF_enumeration.addEnumeration(unicode_value='1', tag='n1')
boolType.n0 = boolType._CF_enumeration.addEnumeration(unicode_value='0', tag='n0')
boolType.x = boolType._CF_enumeration.addEnumeration(unicode_value='x', tag='x')
boolType.emptyString = boolType._CF_enumeration.addEnumeration(unicode_value='-', tag='emptyString')
boolType._InitializeFacetMap(boolType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'boolType', boolType)
_module_typeBindings.boolType = boolType
# Atomic simple type: [anonymous]
class STD_ANON_5 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 74, 12)
_Documentation = None
STD_ANON_5._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_5._CF_pattern.addPattern(pattern='(0|(0?.(\\d+))|(1|1.0*)),(0|(0?.(\\d+))|(1|1.0*)),(0|(0?.(\\d+))|(1|1.0*))(,(0|(0?.(\\d+))|(1|1.0*)))?')
STD_ANON_5._InitializeFacetMap(STD_ANON_5._CF_pattern)
_module_typeBindings.STD_ANON_5 = STD_ANON_5
# Atomic simple type: [anonymous]
class STD_ANON_6 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 79, 12)
_Documentation = None
STD_ANON_6._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_6._CF_pattern.addPattern(pattern='(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5]),(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5]),(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])(,(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5]))?')
STD_ANON_6._InitializeFacetMap(STD_ANON_6._CF_pattern)
_module_typeBindings.STD_ANON_6 = STD_ANON_6
# Atomic simple type: [anonymous]
class STD_ANON_7 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 84, 12)
_Documentation = None
STD_ANON_7._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_7, enum_prefix=None)
STD_ANON_7.red = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='red', tag='red')
STD_ANON_7.green = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='green', tag='green')
STD_ANON_7.blue = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='blue', tag='blue')
STD_ANON_7.yellow = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='yellow', tag='yellow')
STD_ANON_7.cyan = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='cyan', tag='cyan')
STD_ANON_7.magenta = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='magenta', tag='magenta')
STD_ANON_7.orange = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='orange', tag='orange')
STD_ANON_7.white = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='white', tag='white')
STD_ANON_7.black = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='black', tag='black')
STD_ANON_7.grey = STD_ANON_7._CF_enumeration.addEnumeration(unicode_value='grey', tag='grey')
STD_ANON_7._InitializeFacetMap(STD_ANON_7._CF_enumeration)
_module_typeBindings.STD_ANON_7 = STD_ANON_7
# Atomic simple type: shapeType
class shapeType (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'shapeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 101, 4)
_Documentation = None
shapeType._CF_pattern = pyxb.binding.facets.CF_pattern()
shapeType._CF_pattern.addPattern(pattern='((\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+)))?(\\s(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+)))?)*)?')
shapeType._InitializeFacetMap(shapeType._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'shapeType', shapeType)
_module_typeBindings.shapeType = shapeType
# Atomic simple type: shapeTypeTwo
class shapeTypeTwo (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'shapeTypeTwo')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 109, 4)
_Documentation = None
shapeTypeTwo._CF_pattern = pyxb.binding.facets.CF_pattern()
shapeTypeTwo._CF_pattern.addPattern(pattern='(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+)))?\\s(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+)))?(\\s(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))(,(\\-)?(\\d+.?|(\\d*.\\d+)))?)*')
shapeTypeTwo._InitializeFacetMap(shapeTypeTwo._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'shapeTypeTwo', shapeTypeTwo)
_module_typeBindings.shapeTypeTwo = shapeTypeTwo
# Atomic simple type: [anonymous]
class STD_ANON_8 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 119, 12)
_Documentation = None
STD_ANON_8._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_8._CF_pattern.addPattern(pattern='(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))')
STD_ANON_8._InitializeFacetMap(STD_ANON_8._CF_pattern)
_module_typeBindings.STD_ANON_8 = STD_ANON_8
# Atomic simple type: [anonymous]
class STD_ANON_9 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 126, 12)
_Documentation = None
STD_ANON_9._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_9._CF_pattern.addPattern(pattern='(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))')
STD_ANON_9._InitializeFacetMap(STD_ANON_9._CF_pattern)
_module_typeBindings.STD_ANON_9 = STD_ANON_9
# Atomic simple type: [anonymous]
class STD_ANON_10 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 133, 12)
_Documentation = None
STD_ANON_10._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_10._CF_pattern.addPattern(pattern='(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+)),(\\-)?(\\d+.?|(\\d*.\\d+))')
STD_ANON_10._InitializeFacetMap(STD_ANON_10._CF_pattern)
_module_typeBindings.STD_ANON_10 = STD_ANON_10
# Atomic simple type: [anonymous]
class STD_ANON_11 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 186, 12)
_Documentation = None
STD_ANON_11._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_11._CF_pattern.addPattern(pattern='(\\-)?(\\d+)(,(\\-)?(\\d+))*')
STD_ANON_11._InitializeFacetMap(STD_ANON_11._CF_pattern)
_module_typeBindings.STD_ANON_11 = STD_ANON_11
# Atomic simple type: tlTypeType
class tlTypeType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'tlTypeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 208, 4)
_Documentation = None
tlTypeType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=tlTypeType, enum_prefix=None)
tlTypeType.actuated = tlTypeType._CF_enumeration.addEnumeration(unicode_value='actuated', tag='actuated')
tlTypeType.delay_based = tlTypeType._CF_enumeration.addEnumeration(unicode_value='delay_based', tag='delay_based')
tlTypeType.static = tlTypeType._CF_enumeration.addEnumeration(unicode_value='static', tag='static')
tlTypeType._InitializeFacetMap(tlTypeType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'tlTypeType', tlTypeType)
_module_typeBindings.tlTypeType = tlTypeType
# Atomic simple type: [anonymous]
class STD_ANON_12 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 222, 12)
_Documentation = None
STD_ANON_12._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_12._CF_pattern.addPattern(pattern='[ruyYgGoOs]+')
STD_ANON_12._InitializeFacetMap(STD_ANON_12._CF_pattern)
_module_typeBindings.STD_ANON_12 = STD_ANON_12
# Atomic simple type: nodeTypeType
class nodeTypeType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'nodeTypeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 257, 4)
_Documentation = None
nodeTypeType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=nodeTypeType, enum_prefix=None)
nodeTypeType.traffic_light = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='traffic_light', tag='traffic_light')
nodeTypeType.right_before_left = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='right_before_left', tag='right_before_left')
nodeTypeType.priority = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='priority', tag='priority')
nodeTypeType.dead_end = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='dead_end', tag='dead_end')
nodeTypeType.unregulated = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='unregulated', tag='unregulated')
nodeTypeType.traffic_light_unregulated = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='traffic_light_unregulated', tag='traffic_light_unregulated')
nodeTypeType.rail_signal = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='rail_signal', tag='rail_signal')
nodeTypeType.allway_stop = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='allway_stop', tag='allway_stop')
nodeTypeType.priority_stop = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='priority_stop', tag='priority_stop')
nodeTypeType.zipper = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='zipper', tag='zipper')
nodeTypeType.rail_crossing = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='rail_crossing', tag='rail_crossing')
nodeTypeType.traffic_light_right_on_red = nodeTypeType._CF_enumeration.addEnumeration(unicode_value='traffic_light_right_on_red', tag='traffic_light_right_on_red')
nodeTypeType._InitializeFacetMap(nodeTypeType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'nodeTypeType', nodeTypeType)
_module_typeBindings.nodeTypeType = nodeTypeType
# Atomic simple type: [anonymous]
class STD_ANON_13 (pyxb.binding.datatypes.string):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 276, 12)
_Documentation = None
STD_ANON_13._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_13._CF_pattern.addPattern(pattern='\\d+(([,;]|\\s)\\d+)*')
STD_ANON_13._InitializeFacetMap(STD_ANON_13._CF_pattern)
_module_typeBindings.STD_ANON_13 = STD_ANON_13
# Atomic simple type: [anonymous]
class STD_ANON_14 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 58, 12)
_Documentation = None
STD_ANON_14._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_14, enum_prefix=None)
STD_ANON_14.right = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='right', tag='right')
STD_ANON_14.center = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='center', tag='center')
STD_ANON_14.arbitrary = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='arbitrary', tag='arbitrary')
STD_ANON_14.nice = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='nice', tag='nice')
STD_ANON_14.compact = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='compact', tag='compact')
STD_ANON_14.left = STD_ANON_14._CF_enumeration.addEnumeration(unicode_value='left', tag='left')
STD_ANON_14._InitializeFacetMap(STD_ANON_14._CF_enumeration)
_module_typeBindings.STD_ANON_14 = STD_ANON_14
# Atomic simple type: [anonymous]
class STD_ANON_15 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 80, 12)
_Documentation = None
STD_ANON_15._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_15, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_15._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_15, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_15._InitializeFacetMap(STD_ANON_15._CF_minInclusive,
STD_ANON_15._CF_maxInclusive)
_module_typeBindings.STD_ANON_15 = STD_ANON_15
# Atomic simple type: [anonymous]
class STD_ANON_16 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 90, 20)
_Documentation = None
STD_ANON_16._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_16, enum_prefix=None)
STD_ANON_16.off = STD_ANON_16._CF_enumeration.addEnumeration(unicode_value='off', tag='off')
STD_ANON_16._InitializeFacetMap(STD_ANON_16._CF_enumeration)
_module_typeBindings.STD_ANON_16 = STD_ANON_16
# Atomic simple type: [anonymous]
class STD_ANON_17 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 116, 12)
_Documentation = None
STD_ANON_17._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_17, enum_prefix=None)
STD_ANON_17.RB425 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='RB425', tag='RB425')
STD_ANON_17.NGT400 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='NGT400', tag='NGT400')
STD_ANON_17.NGT400_16 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='NGT400_16', tag='NGT400_16')
STD_ANON_17.ICE1 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='ICE1', tag='ICE1')
STD_ANON_17.ICE3 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='ICE3', tag='ICE3')
STD_ANON_17.REDosto7 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='REDosto7', tag='REDosto7')
STD_ANON_17.RB628 = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='RB628', tag='RB628')
STD_ANON_17.Freight = STD_ANON_17._CF_enumeration.addEnumeration(unicode_value='Freight', tag='Freight')
STD_ANON_17._InitializeFacetMap(STD_ANON_17._CF_enumeration)
_module_typeBindings.STD_ANON_17 = STD_ANON_17
# Atomic simple type: [anonymous]
class STD_ANON_18 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 131, 12)
_Documentation = None
STD_ANON_18._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_18, enum_prefix=None)
STD_ANON_18.default = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='default', tag='default')
STD_ANON_18.DK2008 = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='DK2008', tag='DK2008')
STD_ANON_18.LC2013 = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='LC2013', tag='LC2013')
STD_ANON_18.SL2015 = STD_ANON_18._CF_enumeration.addEnumeration(unicode_value='SL2015', tag='SL2015')
STD_ANON_18._InitializeFacetMap(STD_ANON_18._CF_enumeration)
_module_typeBindings.STD_ANON_18 = STD_ANON_18
# Atomic simple type: [anonymous]
class STD_ANON_19 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 148, 12)
_Documentation = None
STD_ANON_19._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_19, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_19._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_19, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_19._InitializeFacetMap(STD_ANON_19._CF_minInclusive,
STD_ANON_19._CF_maxInclusive)
_module_typeBindings.STD_ANON_19 = STD_ANON_19
# Atomic simple type: [anonymous]
class STD_ANON_20 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 164, 12)
_Documentation = None
STD_ANON_20._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_20, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_20._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_20, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_20._InitializeFacetMap(STD_ANON_20._CF_minInclusive,
STD_ANON_20._CF_maxInclusive)
_module_typeBindings.STD_ANON_20 = STD_ANON_20
# Atomic simple type: [anonymous]
class STD_ANON_21 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 181, 12)
_Documentation = None
STD_ANON_21._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_21, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_21._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_21, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_21._InitializeFacetMap(STD_ANON_21._CF_minInclusive,
STD_ANON_21._CF_maxInclusive)
_module_typeBindings.STD_ANON_21 = STD_ANON_21
# Atomic simple type: [anonymous]
class STD_ANON_22 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 195, 12)
_Documentation = None
STD_ANON_22._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_22, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_22._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_22, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_22._InitializeFacetMap(STD_ANON_22._CF_minInclusive,
STD_ANON_22._CF_maxInclusive)
_module_typeBindings.STD_ANON_22 = STD_ANON_22
# Atomic simple type: [anonymous]
class STD_ANON_23 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 214, 12)
_Documentation = None
STD_ANON_23._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_23, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_23._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_23, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_23._InitializeFacetMap(STD_ANON_23._CF_minInclusive,
STD_ANON_23._CF_maxInclusive)
_module_typeBindings.STD_ANON_23 = STD_ANON_23
# Atomic simple type: [anonymous]
class STD_ANON_24 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 230, 12)
_Documentation = None
STD_ANON_24._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_24, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_24._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_24, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_24._InitializeFacetMap(STD_ANON_24._CF_minInclusive,
STD_ANON_24._CF_maxInclusive)
_module_typeBindings.STD_ANON_24 = STD_ANON_24
# Atomic simple type: [anonymous]
class STD_ANON_25 (pyxb.binding.datatypes.float):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 246, 12)
_Documentation = None
STD_ANON_25._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=STD_ANON_25, value=pyxb.binding.datatypes.float(0.0))
STD_ANON_25._CF_maxInclusive = pyxb.binding.facets.CF_maxInclusive(value_datatype=STD_ANON_25, value=pyxb.binding.datatypes.float(1.0))
STD_ANON_25._InitializeFacetMap(STD_ANON_25._CF_minInclusive,
STD_ANON_25._CF_maxInclusive)
_module_typeBindings.STD_ANON_25 = STD_ANON_25
# Atomic simple type: [anonymous]
class STD_ANON_26 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 381, 12)
_Documentation = None
STD_ANON_26._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_26, enum_prefix=None)
STD_ANON_26.triggered = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='triggered', tag='triggered')
STD_ANON_26.containerTriggered = STD_ANON_26._CF_enumeration.addEnumeration(unicode_value='containerTriggered', tag='containerTriggered')
STD_ANON_26._InitializeFacetMap(STD_ANON_26._CF_enumeration)
_module_typeBindings.STD_ANON_26 = STD_ANON_26
# Atomic simple type: [anonymous]
class STD_ANON_27 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 392, 12)
_Documentation = None
STD_ANON_27._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_27, enum_prefix=None)
STD_ANON_27.random = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='random', tag='random')
STD_ANON_27.free = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='free', tag='free')
STD_ANON_27.allowed = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='allowed', tag='allowed')
STD_ANON_27.first = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='first', tag='first')
STD_ANON_27.best = STD_ANON_27._CF_enumeration.addEnumeration(unicode_value='best', tag='best')
STD_ANON_27._InitializeFacetMap(STD_ANON_27._CF_enumeration)
_module_typeBindings.STD_ANON_27 = STD_ANON_27
# Atomic simple type: [anonymous]
class STD_ANON_28 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 406, 12)
_Documentation = None
STD_ANON_28._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_28, enum_prefix=None)
STD_ANON_28.random = STD_ANON_28._CF_enumeration.addEnumeration(unicode_value='random', tag='random')
STD_ANON_28.random_free = STD_ANON_28._CF_enumeration.addEnumeration(unicode_value='random_free', tag='random_free')
STD_ANON_28.free = STD_ANON_28._CF_enumeration.addEnumeration(unicode_value='free', tag='free')
STD_ANON_28.base = STD_ANON_28._CF_enumeration.addEnumeration(unicode_value='base', tag='base')
STD_ANON_28.last = STD_ANON_28._CF_enumeration.addEnumeration(unicode_value='last', tag='last')
STD_ANON_28._InitializeFacetMap(STD_ANON_28._CF_enumeration)
_module_typeBindings.STD_ANON_28 = STD_ANON_28
# Atomic simple type: [anonymous]
class STD_ANON_29 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 420, 12)
_Documentation = None
STD_ANON_29._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_29, enum_prefix=None)
STD_ANON_29.random = STD_ANON_29._CF_enumeration.addEnumeration(unicode_value='random', tag='random')
STD_ANON_29.max = STD_ANON_29._CF_enumeration.addEnumeration(unicode_value='max', tag='max')
STD_ANON_29._InitializeFacetMap(STD_ANON_29._CF_enumeration)
_module_typeBindings.STD_ANON_29 = STD_ANON_29
# Atomic simple type: [anonymous]
class STD_ANON_30 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 431, 12)
_Documentation = None
STD_ANON_30._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_30, enum_prefix=None)
STD_ANON_30.current = STD_ANON_30._CF_enumeration.addEnumeration(unicode_value='current', tag='current')
STD_ANON_30._InitializeFacetMap(STD_ANON_30._CF_enumeration)
_module_typeBindings.STD_ANON_30 = STD_ANON_30
# Atomic simple type: [anonymous]
class STD_ANON_31 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 441, 12)
_Documentation = None
STD_ANON_31._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_31, enum_prefix=None)
STD_ANON_31.random = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='random', tag='random')
STD_ANON_31.max = STD_ANON_31._CF_enumeration.addEnumeration(unicode_value='max', tag='max')
STD_ANON_31._InitializeFacetMap(STD_ANON_31._CF_enumeration)
_module_typeBindings.STD_ANON_31 = STD_ANON_31
# Atomic simple type: [anonymous]
class STD_ANON_32 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 452, 12)
_Documentation = None
STD_ANON_32._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_32, enum_prefix=None)
STD_ANON_32.random = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='random', tag='random')
STD_ANON_32.free = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='free', tag='free')
STD_ANON_32.random_free = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='random_free', tag='random_free')
STD_ANON_32.right = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='right', tag='right')
STD_ANON_32.center = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='center', tag='center')
STD_ANON_32.left = STD_ANON_32._CF_enumeration.addEnumeration(unicode_value='left', tag='left')
STD_ANON_32._InitializeFacetMap(STD_ANON_32._CF_enumeration)
_module_typeBindings.STD_ANON_32 = STD_ANON_32
# Atomic simple type: [anonymous]
class STD_ANON_33 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 467, 12)
_Documentation = None
STD_ANON_33._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_33, enum_prefix=None)
STD_ANON_33.right = STD_ANON_33._CF_enumeration.addEnumeration(unicode_value='right', tag='right')
STD_ANON_33.center = STD_ANON_33._CF_enumeration.addEnumeration(unicode_value='center', tag='center')
STD_ANON_33.left = STD_ANON_33._CF_enumeration.addEnumeration(unicode_value='left', tag='left')
STD_ANON_33._InitializeFacetMap(STD_ANON_33._CF_enumeration)
_module_typeBindings.STD_ANON_33 = STD_ANON_33
# Atomic simple type: [anonymous]
class STD_ANON_34 (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):
"""An atomic simple type."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 479, 12)
_Documentation = None
STD_ANON_34._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_34, enum_prefix=None)
STD_ANON_34.current = STD_ANON_34._CF_enumeration.addEnumeration(unicode_value='current', tag='current')
STD_ANON_34._InitializeFacetMap(STD_ANON_34._CF_enumeration)
_module_typeBindings.STD_ANON_34 = STD_ANON_34
# Union simple type: [anonymous]
# superclasses pyxb.binding.datatypes.anySimpleType
class STD_ANON_35 (pyxb.binding.basis.STD_union):
"""Simple type that is a union of boolType, STD_ANON_."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 136, 12)
_Documentation = None
_MemberTypes = ( boolType, STD_ANON_, )
STD_ANON_35._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_35._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_35)
STD_ANON_35.true = 'true' # originally boolType.true
STD_ANON_35.false = 'false' # originally boolType.false
STD_ANON_35.True_ = 'True' # originally boolType.True_
STD_ANON_35.False_ = 'False' # originally boolType.False_
STD_ANON_35.yes = 'yes' # originally boolType.yes
STD_ANON_35.no = 'no' # originally boolType.no
STD_ANON_35.on = 'on' # originally boolType.on
STD_ANON_35.off = 'off' # originally boolType.off
STD_ANON_35.n1 = '1' # originally boolType.n1
STD_ANON_35.n0 = '0' # originally boolType.n0
STD_ANON_35.x = 'x' # originally boolType.x
STD_ANON_35.emptyString = '-' # originally boolType.emptyString
STD_ANON_35.defaults = 'defaults' # originally STD_ANON_.defaults
STD_ANON_35._InitializeFacetMap(STD_ANON_35._CF_pattern,
STD_ANON_35._CF_enumeration)
_module_typeBindings.STD_ANON_35 = STD_ANON_35
# Union simple type: nonNegativeFloatTypeWithErrorValue
# superclasses pyxb.binding.datatypes.anySimpleType
class nonNegativeFloatTypeWithErrorValue (pyxb.binding.basis.STD_union):
"""Simple type that is a union of nonNegativeFloatType, STD_ANON_3."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'nonNegativeFloatTypeWithErrorValue')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 22, 4)
_Documentation = None
_MemberTypes = ( nonNegativeFloatType, STD_ANON_3, )
nonNegativeFloatTypeWithErrorValue._CF_pattern = pyxb.binding.facets.CF_pattern()
nonNegativeFloatTypeWithErrorValue._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=nonNegativeFloatTypeWithErrorValue)
nonNegativeFloatTypeWithErrorValue._InitializeFacetMap(nonNegativeFloatTypeWithErrorValue._CF_pattern,
nonNegativeFloatTypeWithErrorValue._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'nonNegativeFloatTypeWithErrorValue', nonNegativeFloatTypeWithErrorValue)
_module_typeBindings.nonNegativeFloatTypeWithErrorValue = nonNegativeFloatTypeWithErrorValue
# Union simple type: nonNegativeDistributionType
# superclasses pyxb.binding.datatypes.anySimpleType
class nonNegativeDistributionType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of nonNegativeFloatType, STD_ANON_4."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'nonNegativeDistributionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 33, 4)
_Documentation = None
_MemberTypes = ( nonNegativeFloatType, STD_ANON_4, )
nonNegativeDistributionType._CF_pattern = pyxb.binding.facets.CF_pattern()
nonNegativeDistributionType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=nonNegativeDistributionType)
nonNegativeDistributionType._InitializeFacetMap(nonNegativeDistributionType._CF_pattern,
nonNegativeDistributionType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'nonNegativeDistributionType', nonNegativeDistributionType)
_module_typeBindings.nonNegativeDistributionType = nonNegativeDistributionType
# Union simple type: colorType
# superclasses pyxb.binding.datatypes.anySimpleType
class colorType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of STD_ANON_5, STD_ANON_6, STD_ANON_7."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'colorType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 72, 4)
_Documentation = None
_MemberTypes = ( STD_ANON_5, STD_ANON_6, STD_ANON_7, )
colorType._CF_pattern = pyxb.binding.facets.CF_pattern()
colorType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=colorType)
colorType.red = 'red' # originally STD_ANON_7.red
colorType.green = 'green' # originally STD_ANON_7.green
colorType.blue = 'blue' # originally STD_ANON_7.blue
colorType.yellow = 'yellow' # originally STD_ANON_7.yellow
colorType.cyan = 'cyan' # originally STD_ANON_7.cyan
colorType.magenta = 'magenta' # originally STD_ANON_7.magenta
colorType.orange = 'orange' # originally STD_ANON_7.orange
colorType.white = 'white' # originally STD_ANON_7.white
colorType.black = 'black' # originally STD_ANON_7.black
colorType.grey = 'grey' # originally STD_ANON_7.grey
colorType._InitializeFacetMap(colorType._CF_pattern,
colorType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'colorType', colorType)
_module_typeBindings.colorType = colorType
# Union simple type: [anonymous]
# superclasses pyxb.binding.datatypes.anySimpleType
class STD_ANON_36 (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.float, STD_ANON_16."""
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 88, 12)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.float, STD_ANON_16, )
STD_ANON_36._CF_pattern = pyxb.binding.facets.CF_pattern()
STD_ANON_36._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=STD_ANON_36)
STD_ANON_36.off = 'off' # originally STD_ANON_16.off
STD_ANON_36._InitializeFacetMap(STD_ANON_36._CF_pattern,
STD_ANON_36._CF_enumeration)
_module_typeBindings.STD_ANON_36 = STD_ANON_36
# Union simple type: departType
# superclasses pyxb.binding.datatypes.anySimpleType
class departType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of nonNegativeFloatType, STD_ANON_26."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'departType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 379, 4)
_Documentation = None
_MemberTypes = ( nonNegativeFloatType, STD_ANON_26, )
departType._CF_pattern = pyxb.binding.facets.CF_pattern()
departType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=departType)
departType.triggered = 'triggered' # originally STD_ANON_26.triggered
departType.containerTriggered = 'containerTriggered'# originally STD_ANON_26.containerTriggered
departType._InitializeFacetMap(departType._CF_pattern,
departType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'departType', departType)
_module_typeBindings.departType = departType
# Union simple type: departLaneType
# superclasses pyxb.binding.datatypes.anySimpleType
class departLaneType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.nonNegativeInteger, STD_ANON_27."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'departLaneType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 390, 4)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.nonNegativeInteger, STD_ANON_27, )
departLaneType._CF_pattern = pyxb.binding.facets.CF_pattern()
departLaneType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=departLaneType)
departLaneType.random = 'random' # originally STD_ANON_27.random
departLaneType.free = 'free' # originally STD_ANON_27.free
departLaneType.allowed = 'allowed' # originally STD_ANON_27.allowed
departLaneType.first = 'first' # originally STD_ANON_27.first
departLaneType.best = 'best' # originally STD_ANON_27.best
departLaneType._InitializeFacetMap(departLaneType._CF_pattern,
departLaneType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'departLaneType', departLaneType)
_module_typeBindings.departLaneType = departLaneType
# Union simple type: departPosType
# superclasses pyxb.binding.datatypes.anySimpleType
class departPosType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.float, STD_ANON_28."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'departPosType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 404, 4)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.float, STD_ANON_28, )
departPosType._CF_pattern = pyxb.binding.facets.CF_pattern()
departPosType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=departPosType)
departPosType.random = 'random' # originally STD_ANON_28.random
departPosType.random_free = 'random_free' # originally STD_ANON_28.random_free
departPosType.free = 'free' # originally STD_ANON_28.free
departPosType.base = 'base' # originally STD_ANON_28.base
departPosType.last = 'last' # originally STD_ANON_28.last
departPosType._InitializeFacetMap(departPosType._CF_pattern,
departPosType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'departPosType', departPosType)
_module_typeBindings.departPosType = departPosType
# Union simple type: departSpeedType
# superclasses pyxb.binding.datatypes.anySimpleType
class departSpeedType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of nonNegativeFloatType, STD_ANON_29."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'departSpeedType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 418, 4)
_Documentation = None
_MemberTypes = ( nonNegativeFloatType, STD_ANON_29, )
departSpeedType._CF_pattern = pyxb.binding.facets.CF_pattern()
departSpeedType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=departSpeedType)
departSpeedType.random = 'random' # originally STD_ANON_29.random
departSpeedType.max = 'max' # originally STD_ANON_29.max
departSpeedType._InitializeFacetMap(departSpeedType._CF_pattern,
departSpeedType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'departSpeedType', departSpeedType)
_module_typeBindings.departSpeedType = departSpeedType
# Union simple type: arrivalLaneType
# superclasses pyxb.binding.datatypes.anySimpleType
class arrivalLaneType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.nonNegativeInteger, STD_ANON_30."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'arrivalLaneType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 429, 4)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.nonNegativeInteger, STD_ANON_30, )
arrivalLaneType._CF_pattern = pyxb.binding.facets.CF_pattern()
arrivalLaneType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=arrivalLaneType)
arrivalLaneType.current = 'current' # originally STD_ANON_30.current
arrivalLaneType._InitializeFacetMap(arrivalLaneType._CF_pattern,
arrivalLaneType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'arrivalLaneType', arrivalLaneType)
_module_typeBindings.arrivalLaneType = arrivalLaneType
# Union simple type: arrivalPosType
# superclasses pyxb.binding.datatypes.anySimpleType
class arrivalPosType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.float, STD_ANON_31."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'arrivalPosType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 439, 4)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.float, STD_ANON_31, )
arrivalPosType._CF_pattern = pyxb.binding.facets.CF_pattern()
arrivalPosType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=arrivalPosType)
arrivalPosType.random = 'random' # originally STD_ANON_31.random
arrivalPosType.max = 'max' # originally STD_ANON_31.max
arrivalPosType._InitializeFacetMap(arrivalPosType._CF_pattern,
arrivalPosType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'arrivalPosType', arrivalPosType)
_module_typeBindings.arrivalPosType = arrivalPosType
# Union simple type: departPosLatType
# superclasses pyxb.binding.datatypes.anySimpleType
class departPosLatType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.float, STD_ANON_32."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'departPosLatType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 450, 4)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.float, STD_ANON_32, )
departPosLatType._CF_pattern = pyxb.binding.facets.CF_pattern()
departPosLatType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=departPosLatType)
departPosLatType.random = 'random' # originally STD_ANON_32.random
departPosLatType.free = 'free' # originally STD_ANON_32.free
departPosLatType.random_free = 'random_free' # originally STD_ANON_32.random_free
departPosLatType.right = 'right' # originally STD_ANON_32.right
departPosLatType.center = 'center' # originally STD_ANON_32.center
departPosLatType.left = 'left' # originally STD_ANON_32.left
departPosLatType._InitializeFacetMap(departPosLatType._CF_pattern,
departPosLatType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'departPosLatType', departPosLatType)
_module_typeBindings.departPosLatType = departPosLatType
# Union simple type: arrivalPosLatType
# superclasses pyxb.binding.datatypes.anySimpleType
class arrivalPosLatType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of pyxb.binding.datatypes.float, STD_ANON_33."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'arrivalPosLatType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 465, 4)
_Documentation = None
_MemberTypes = ( pyxb.binding.datatypes.float, STD_ANON_33, )
arrivalPosLatType._CF_pattern = pyxb.binding.facets.CF_pattern()
arrivalPosLatType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=arrivalPosLatType)
arrivalPosLatType.right = 'right' # originally STD_ANON_33.right
arrivalPosLatType.center = 'center' # originally STD_ANON_33.center
arrivalPosLatType.left = 'left' # originally STD_ANON_33.left
arrivalPosLatType._InitializeFacetMap(arrivalPosLatType._CF_pattern,
arrivalPosLatType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'arrivalPosLatType', arrivalPosLatType)
_module_typeBindings.arrivalPosLatType = arrivalPosLatType
# Union simple type: arrivalSpeedType
# superclasses pyxb.binding.datatypes.anySimpleType
class arrivalSpeedType (pyxb.binding.basis.STD_union):
"""Simple type that is a union of nonNegativeFloatType, STD_ANON_34."""
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'arrivalSpeedType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 477, 4)
_Documentation = None
_MemberTypes = ( nonNegativeFloatType, STD_ANON_34, )
arrivalSpeedType._CF_pattern = pyxb.binding.facets.CF_pattern()
arrivalSpeedType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=arrivalSpeedType)
arrivalSpeedType.current = 'current' # originally STD_ANON_34.current
arrivalSpeedType._InitializeFacetMap(arrivalSpeedType._CF_pattern,
arrivalSpeedType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'arrivalSpeedType', arrivalSpeedType)
_module_typeBindings.arrivalSpeedType = arrivalSpeedType
# Complex type additionalType with content type ELEMENT_ONLY
class additionalType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type additionalType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'additionalType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 9, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element location uses Python identifier location
__location = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'location'), 'location', '__AbsentNamespace0_additionalType_location', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 11, 12), )
location = property(__location.value, __location.set, None, None)
# Element vTypeProbe uses Python identifier vTypeProbe
__vTypeProbe = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'vTypeProbe'), 'vTypeProbe', '__AbsentNamespace0_additionalType_vTypeProbe', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 12, 12), )
vTypeProbe = property(__vTypeProbe.value, __vTypeProbe.set, None, None)
# Element e1Detector uses Python identifier e1Detector
__e1Detector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'e1Detector'), 'e1Detector', '__AbsentNamespace0_additionalType_e1Detector', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 13, 12), )
e1Detector = property(__e1Detector.value, __e1Detector.set, None, None)
# Element inductionLoop uses Python identifier inductionLoop
__inductionLoop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'inductionLoop'), 'inductionLoop', '__AbsentNamespace0_additionalType_inductionLoop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 14, 12), )
inductionLoop = property(__inductionLoop.value, __inductionLoop.set, None, None)
# Element e2Detector uses Python identifier e2Detector
__e2Detector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'e2Detector'), 'e2Detector', '__AbsentNamespace0_additionalType_e2Detector', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 15, 12), )
e2Detector = property(__e2Detector.value, __e2Detector.set, None, None)
# Element laneAreaDetector uses Python identifier laneAreaDetector
__laneAreaDetector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'laneAreaDetector'), 'laneAreaDetector', '__AbsentNamespace0_additionalType_laneAreaDetector', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 16, 12), )
laneAreaDetector = property(__laneAreaDetector.value, __laneAreaDetector.set, None, None)
# Element e3Detector uses Python identifier e3Detector
__e3Detector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'e3Detector'), 'e3Detector', '__AbsentNamespace0_additionalType_e3Detector', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 17, 12), )
e3Detector = property(__e3Detector.value, __e3Detector.set, None, None)
# Element entryExitDetector uses Python identifier entryExitDetector
__entryExitDetector = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'entryExitDetector'), 'entryExitDetector', '__AbsentNamespace0_additionalType_entryExitDetector', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 18, 12), )
entryExitDetector = property(__entryExitDetector.value, __entryExitDetector.set, None, None)
# Element edgeData uses Python identifier edgeData
__edgeData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'edgeData'), 'edgeData', '__AbsentNamespace0_additionalType_edgeData', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 19, 12), )
edgeData = property(__edgeData.value, __edgeData.set, None, None)
# Element laneData uses Python identifier laneData
__laneData = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'laneData'), 'laneData', '__AbsentNamespace0_additionalType_laneData', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 20, 12), )
laneData = property(__laneData.value, __laneData.set, None, None)
# Element timedEvent uses Python identifier timedEvent
__timedEvent = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'timedEvent'), 'timedEvent', '__AbsentNamespace0_additionalType_timedEvent', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 21, 12), )
timedEvent = property(__timedEvent.value, __timedEvent.set, None, None)
# Element tlLogic uses Python identifier tlLogic
__tlLogic = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'tlLogic'), 'tlLogic', '__AbsentNamespace0_additionalType_tlLogic', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 22, 12), )
tlLogic = property(__tlLogic.value, __tlLogic.set, None, None)
# Element WAUT uses Python identifier WAUT
__WAUT = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'WAUT'), 'WAUT', '__AbsentNamespace0_additionalType_WAUT', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 23, 12), )
WAUT = property(__WAUT.value, __WAUT.set, None, None)
# Element wautJunction uses Python identifier wautJunction
__wautJunction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'wautJunction'), 'wautJunction', '__AbsentNamespace0_additionalType_wautJunction', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 24, 12), )
wautJunction = property(__wautJunction.value, __wautJunction.set, None, None)
# Element variableSpeedSign uses Python identifier variableSpeedSign
__variableSpeedSign = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'variableSpeedSign'), 'variableSpeedSign', '__AbsentNamespace0_additionalType_variableSpeedSign', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 25, 12), )
variableSpeedSign = property(__variableSpeedSign.value, __variableSpeedSign.set, None, None)
# Element routeProbe uses Python identifier routeProbe
__routeProbe = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'routeProbe'), 'routeProbe', '__AbsentNamespace0_additionalType_routeProbe', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 26, 12), )
routeProbe = property(__routeProbe.value, __routeProbe.set, None, None)
# Element rerouter uses Python identifier rerouter
__rerouter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'rerouter'), 'rerouter', '__AbsentNamespace0_additionalType_rerouter', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 27, 12), )
rerouter = property(__rerouter.value, __rerouter.set, None, None)
# Element instantInductionLoop uses Python identifier instantInductionLoop
__instantInductionLoop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'instantInductionLoop'), 'instantInductionLoop', '__AbsentNamespace0_additionalType_instantInductionLoop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 28, 12), )
instantInductionLoop = property(__instantInductionLoop.value, __instantInductionLoop.set, None, None)
# Element busStop uses Python identifier busStop
__busStop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'busStop'), 'busStop', '__AbsentNamespace0_additionalType_busStop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 29, 12), )
busStop = property(__busStop.value, __busStop.set, None, None)
# Element trainStop uses Python identifier trainStop
__trainStop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'trainStop'), 'trainStop', '__AbsentNamespace0_additionalType_trainStop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 30, 12), )
trainStop = property(__trainStop.value, __trainStop.set, None, None)
# Element containerStop uses Python identifier containerStop
__containerStop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'containerStop'), 'containerStop', '__AbsentNamespace0_additionalType_containerStop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 31, 12), )
containerStop = property(__containerStop.value, __containerStop.set, None, None)
# Element chargingStation uses Python identifier chargingStation
__chargingStation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'chargingStation'), 'chargingStation', '__AbsentNamespace0_additionalType_chargingStation', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 32, 12), )
chargingStation = property(__chargingStation.value, __chargingStation.set, None, None)
# Element parkingArea uses Python identifier parkingArea
__parkingArea = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'parkingArea'), 'parkingArea', '__AbsentNamespace0_additionalType_parkingArea', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 33, 12), )
parkingArea = property(__parkingArea.value, __parkingArea.set, None, None)
# Element calibrator uses Python identifier calibrator
__calibrator = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'calibrator'), 'calibrator', '__AbsentNamespace0_additionalType_calibrator', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 34, 12), )
calibrator = property(__calibrator.value, __calibrator.set, None, None)
# Element vaporizer uses Python identifier vaporizer
__vaporizer = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'vaporizer'), 'vaporizer', '__AbsentNamespace0_additionalType_vaporizer', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 35, 12), )
vaporizer = property(__vaporizer.value, __vaporizer.set, None, None)
# Element vTypeDistribution uses Python identifier vTypeDistribution
__vTypeDistribution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'vTypeDistribution'), 'vTypeDistribution', '__AbsentNamespace0_additionalType_vTypeDistribution', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 37, 12), )
vTypeDistribution = property(__vTypeDistribution.value, __vTypeDistribution.set, None, None)
# Element routeDistribution uses Python identifier routeDistribution
__routeDistribution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'routeDistribution'), 'routeDistribution', '__AbsentNamespace0_additionalType_routeDistribution', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 38, 12), )
routeDistribution = property(__routeDistribution.value, __routeDistribution.set, None, None)
# Element vType uses Python identifier vType
__vType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'vType'), 'vType', '__AbsentNamespace0_additionalType_vType', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 39, 12), )
vType = property(__vType.value, __vType.set, None, None)
# Element route uses Python identifier route
__route = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_additionalType_route', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 40, 12), )
route = property(__route.value, __route.set, None, None)
# Element vehicle uses Python identifier vehicle
__vehicle = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'vehicle'), 'vehicle', '__AbsentNamespace0_additionalType_vehicle', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 41, 12), )
vehicle = property(__vehicle.value, __vehicle.set, None, None)
# Element flow uses Python identifier flow
__flow = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'flow'), 'flow', '__AbsentNamespace0_additionalType_flow', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 42, 12), )
flow = property(__flow.value, __flow.set, None, None)
# Element person uses Python identifier person
__person = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'person'), 'person', '__AbsentNamespace0_additionalType_person', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 43, 12), )
person = property(__person.value, __person.set, None, None)
# Element interval uses Python identifier interval
__interval = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'interval'), 'interval', '__AbsentNamespace0_additionalType_interval', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 45, 12), )
interval = property(__interval.value, __interval.set, None, None)
# Element poly uses Python identifier poly
__poly = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'poly'), 'poly', '__AbsentNamespace0_additionalType_poly', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 47, 12), )
poly = property(__poly.value, __poly.set, None, None)
# Element poi uses Python identifier poi
__poi = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'poi'), 'poi', '__AbsentNamespace0_additionalType_poi', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 48, 12), )
poi = property(__poi.value, __poi.set, None, None)
# Element type uses Python identifier type
__type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_additionalType_type', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 50, 12), )
type = property(__type.value, __type.set, None, None)
# Element include uses Python identifier include
__include = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'include'), 'include', '__AbsentNamespace0_additionalType_include', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 52, 12), )
include = property(__include.value, __include.set, None, None)
_ElementMap.update({
__location.name() : __location,
__vTypeProbe.name() : __vTypeProbe,
__e1Detector.name() : __e1Detector,
__inductionLoop.name() : __inductionLoop,
__e2Detector.name() : __e2Detector,
__laneAreaDetector.name() : __laneAreaDetector,
__e3Detector.name() : __e3Detector,
__entryExitDetector.name() : __entryExitDetector,
__edgeData.name() : __edgeData,
__laneData.name() : __laneData,
__timedEvent.name() : __timedEvent,
__tlLogic.name() : __tlLogic,
__WAUT.name() : __WAUT,
__wautJunction.name() : __wautJunction,
__variableSpeedSign.name() : __variableSpeedSign,
__routeProbe.name() : __routeProbe,
__rerouter.name() : __rerouter,
__instantInductionLoop.name() : __instantInductionLoop,
__busStop.name() : __busStop,
__trainStop.name() : __trainStop,
__containerStop.name() : __containerStop,
__chargingStation.name() : __chargingStation,
__parkingArea.name() : __parkingArea,
__calibrator.name() : __calibrator,
__vaporizer.name() : __vaporizer,
__vTypeDistribution.name() : __vTypeDistribution,
__routeDistribution.name() : __routeDistribution,
__vType.name() : __vType,
__route.name() : __route,
__vehicle.name() : __vehicle,
__flow.name() : __flow,
__person.name() : __person,
__interval.name() : __interval,
__poly.name() : __poly,
__poi.name() : __poi,
__type.name() : __type,
__include.name() : __include
})
_AttributeMap.update({
})
_module_typeBindings.additionalType = additionalType
Namespace.addCategoryObject('typeBinding', 'additionalType', additionalType)
# Complex type [anonymous] with content type EMPTY
class CTD_ANON (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 53, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute href uses Python identifier href
__href = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'href'), 'href', '__AbsentNamespace0_CTD_ANON_href', pyxb.binding.datatypes.string)
__href._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 54, 20)
__href._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 54, 20)
href = property(__href.value, __href.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__href.name() : __href
})
_module_typeBindings.CTD_ANON = CTD_ANON
# Complex type WAUTType with content type ELEMENT_ONLY
class WAUTType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type WAUTType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'WAUTType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 165, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element wautSwitch uses Python identifier wautSwitch
__wautSwitch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'wautSwitch'), 'wautSwitch', '__AbsentNamespace0_WAUTType_wautSwitch', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 167, 12), )
wautSwitch = property(__wautSwitch.value, __wautSwitch.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_WAUTType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 169, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 169, 8)
id = property(__id.value, __id.set, None, None)
# Attribute refTime uses Python identifier refTime
__refTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'refTime'), 'refTime', '__AbsentNamespace0_WAUTType_refTime', pyxb.binding.datatypes.int, required=True)
__refTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 170, 8)
__refTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 170, 8)
refTime = property(__refTime.value, __refTime.set, None, None)
# Attribute startProg uses Python identifier startProg
__startProg = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'startProg'), 'startProg', '__AbsentNamespace0_WAUTType_startProg', pyxb.binding.datatypes.string, required=True)
__startProg._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 171, 8)
__startProg._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 171, 8)
startProg = property(__startProg.value, __startProg.set, None, None)
_ElementMap.update({
__wautSwitch.name() : __wautSwitch
})
_AttributeMap.update({
__id.name() : __id,
__refTime.name() : __refTime,
__startProg.name() : __startProg
})
_module_typeBindings.WAUTType = WAUTType
Namespace.addCategoryObject('typeBinding', 'WAUTType', WAUTType)
# Complex type wautSwitchType with content type EMPTY
class wautSwitchType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type wautSwitchType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'wautSwitchType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 174, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute time uses Python identifier time
__time = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__AbsentNamespace0_wautSwitchType_time', pyxb.binding.datatypes.int, required=True)
__time._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 175, 8)
__time._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 175, 8)
time = property(__time.value, __time.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_wautSwitchType_to', pyxb.binding.datatypes.string, required=True)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 176, 8)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 176, 8)
to = property(__to.value, __to.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__time.name() : __time,
__to.name() : __to
})
_module_typeBindings.wautSwitchType = wautSwitchType
Namespace.addCategoryObject('typeBinding', 'wautSwitchType', wautSwitchType)
# Complex type wautJunctionType with content type EMPTY
class wautJunctionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type wautJunctionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'wautJunctionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 179, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute wautID uses Python identifier wautID
__wautID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'wautID'), 'wautID', '__AbsentNamespace0_wautJunctionType_wautID', pyxb.binding.datatypes.string, required=True)
__wautID._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 180, 8)
__wautID._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 180, 8)
wautID = property(__wautID.value, __wautID.set, None, None)
# Attribute junctionID uses Python identifier junctionID
__junctionID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'junctionID'), 'junctionID', '__AbsentNamespace0_wautJunctionType_junctionID', pyxb.binding.datatypes.string, required=True)
__junctionID._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 181, 8)
__junctionID._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 181, 8)
junctionID = property(__junctionID.value, __junctionID.set, None, None)
# Attribute procedure uses Python identifier procedure
__procedure = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'procedure'), 'procedure', '__AbsentNamespace0_wautJunctionType_procedure', pyxb.binding.datatypes.string)
__procedure._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 182, 8)
__procedure._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 182, 8)
procedure = property(__procedure.value, __procedure.set, None, None)
# Attribute synchron uses Python identifier synchron
__synchron = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synchron'), 'synchron', '__AbsentNamespace0_wautJunctionType_synchron', pyxb.binding.datatypes.string)
__synchron._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 183, 8)
__synchron._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 183, 8)
synchron = property(__synchron.value, __synchron.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__wautID.name() : __wautID,
__junctionID.name() : __junctionID,
__procedure.name() : __procedure,
__synchron.name() : __synchron
})
_module_typeBindings.wautJunctionType = wautJunctionType
Namespace.addCategoryObject('typeBinding', 'wautJunctionType', wautJunctionType)
# Complex type variableSpeedSignType with content type ELEMENT_ONLY
class variableSpeedSignType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type variableSpeedSignType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'variableSpeedSignType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 186, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element step uses Python identifier step
__step = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'step'), 'step', '__AbsentNamespace0_variableSpeedSignType_step', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 188, 12), )
step = property(__step.value, __step.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_variableSpeedSignType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 195, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 195, 8)
id = property(__id.value, __id.set, None, None)
# Attribute lanes uses Python identifier lanes
__lanes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lanes'), 'lanes', '__AbsentNamespace0_variableSpeedSignType_lanes', pyxb.binding.datatypes.string, required=True)
__lanes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 196, 8)
__lanes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 196, 8)
lanes = property(__lanes.value, __lanes.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_variableSpeedSignType_file', pyxb.binding.datatypes.string)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 197, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 197, 8)
file = property(__file.value, __file.set, None, None)
_ElementMap.update({
__step.name() : __step
})
_AttributeMap.update({
__id.name() : __id,
__lanes.name() : __lanes,
__file.name() : __file
})
_module_typeBindings.variableSpeedSignType = variableSpeedSignType
Namespace.addCategoryObject('typeBinding', 'variableSpeedSignType', variableSpeedSignType)
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_ (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 215, 28)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_CTD_ANON__id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 216, 32)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 216, 32)
id = property(__id.value, __id.set, None, None)
# Attribute allow uses Python identifier allow
__allow = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'allow'), 'allow', '__AbsentNamespace0_CTD_ANON__allow', pyxb.binding.datatypes.string)
__allow._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 217, 32)
__allow._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 217, 32)
allow = property(__allow.value, __allow.set, None, None)
# Attribute disallow uses Python identifier disallow
__disallow = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'disallow'), 'disallow', '__AbsentNamespace0_CTD_ANON__disallow', pyxb.binding.datatypes.string)
__disallow._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 218, 32)
__disallow._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 218, 32)
disallow = property(__disallow.value, __disallow.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__allow.name() : __allow,
__disallow.name() : __disallow
})
_module_typeBindings.CTD_ANON_ = CTD_ANON_
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_2 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 222, 28)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_CTD_ANON_2_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 223, 32)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 223, 32)
id = property(__id.value, __id.set, None, None)
# Attribute allow uses Python identifier allow
__allow = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'allow'), 'allow', '__AbsentNamespace0_CTD_ANON_2_allow', pyxb.binding.datatypes.string)
__allow._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 224, 32)
__allow._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 224, 32)
allow = property(__allow.value, __allow.set, None, None)
# Attribute disallow uses Python identifier disallow
__disallow = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'disallow'), 'disallow', '__AbsentNamespace0_CTD_ANON_2_disallow', pyxb.binding.datatypes.string)
__disallow._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 225, 32)
__disallow._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 225, 32)
disallow = property(__disallow.value, __disallow.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__allow.name() : __allow,
__disallow.name() : __disallow
})
_module_typeBindings.CTD_ANON_2 = CTD_ANON_2
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_3 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 269, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_CTD_ANON_3_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 270, 20)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 270, 20)
lane = property(__lane.value, __lane.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_CTD_ANON_3_pos', pyxb.binding.datatypes.float, required=True)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 271, 20)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 271, 20)
pos = property(__pos.value, __pos.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__lane.name() : __lane,
__pos.name() : __pos
})
_module_typeBindings.CTD_ANON_3 = CTD_ANON_3
# Complex type intOptionType with content type EMPTY
class intOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type intOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'intOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 149, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_intOptionType_value', pyxb.binding.datatypes.int, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 150, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 150, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_intOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 151, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 151, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_intOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 152, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 152, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_intOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 153, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 153, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.intOptionType = intOptionType
Namespace.addCategoryObject('typeBinding', 'intOptionType', intOptionType)
# Complex type floatOptionType with content type EMPTY
class floatOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type floatOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'floatOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 156, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_floatOptionType_value', pyxb.binding.datatypes.float, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 157, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 157, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_floatOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 158, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 158, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_floatOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 159, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 159, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_floatOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 160, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 160, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.floatOptionType = floatOptionType
Namespace.addCategoryObject('typeBinding', 'floatOptionType', floatOptionType)
# Complex type timeOptionType with content type EMPTY
class timeOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type timeOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'timeOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 163, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_timeOptionType_value', pyxb.binding.datatypes.float, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 164, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 164, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_timeOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 165, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 165, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_timeOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 166, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 166, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_timeOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 167, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 167, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.timeOptionType = timeOptionType
Namespace.addCategoryObject('typeBinding', 'timeOptionType', timeOptionType)
# Complex type strOptionType with content type EMPTY
class strOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type strOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'strOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 170, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_strOptionType_value', pyxb.binding.datatypes.string, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 171, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 171, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_strOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 172, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 172, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_strOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 173, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 173, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_strOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 174, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 174, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.strOptionType = strOptionType
Namespace.addCategoryObject('typeBinding', 'strOptionType', strOptionType)
# Complex type fileOptionType with content type EMPTY
class fileOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type fileOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'fileOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 177, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_fileOptionType_value', pyxb.binding.datatypes.string, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 178, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 178, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_fileOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 179, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 179, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_fileOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 180, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 180, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_fileOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 181, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 181, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.fileOptionType = fileOptionType
Namespace.addCategoryObject('typeBinding', 'fileOptionType', fileOptionType)
# Complex type paramType with content type EMPTY
class paramType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type paramType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'paramType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 230, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute key uses Python identifier key
__key = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'key'), 'key', '__AbsentNamespace0_paramType_key', pyxb.binding.datatypes.string, required=True)
__key._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 231, 8)
__key._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 231, 8)
key = property(__key.value, __key.set, None, None)
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_paramType_value', pyxb.binding.datatypes.string, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 232, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 232, 8)
value_ = property(__value.value, __value.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__key.name() : __key,
__value.name() : __value
})
_module_typeBindings.paramType = paramType
Namespace.addCategoryObject('typeBinding', 'paramType', paramType)
# Complex type restrictionType with content type EMPTY
class restrictionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type restrictionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'restrictionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 252, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute vClass uses Python identifier vClass
__vClass = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vClass'), 'vClass', '__AbsentNamespace0_restrictionType_vClass', pyxb.binding.datatypes.string, required=True)
__vClass._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 253, 8)
__vClass._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 253, 8)
vClass = property(__vClass.value, __vClass.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_restrictionType_speed', pyxb.binding.datatypes.float, required=True)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 254, 8)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 254, 8)
speed = property(__speed.value, __speed.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__vClass.name() : __vClass,
__speed.name() : __speed
})
_module_typeBindings.restrictionType = restrictionType
Namespace.addCategoryObject('typeBinding', 'restrictionType', restrictionType)
# Complex type vTypeDistributionType with content type ELEMENT_ONLY
class vTypeDistributionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vTypeDistributionType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vTypeDistributionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 531, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element vType uses Python identifier vType
__vType = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'vType'), 'vType', '__AbsentNamespace0_vTypeDistributionType_vType', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 533, 12), )
vType = property(__vType.value, __vType.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_vTypeDistributionType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 535, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 535, 8)
id = property(__id.value, __id.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_vTypeDistributionType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 536, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 536, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
_ElementMap.update({
__vType.name() : __vType
})
_AttributeMap.update({
__id.name() : __id,
__vTypes.name() : __vTypes
})
_module_typeBindings.vTypeDistributionType = vTypeDistributionType
Namespace.addCategoryObject('typeBinding', 'vTypeDistributionType', vTypeDistributionType)
# Complex type routeDistributionType with content type ELEMENT_ONLY
class routeDistributionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type routeDistributionType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'routeDistributionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 539, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element route uses Python identifier route
__route = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_routeDistributionType_route', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 541, 12), )
route = property(__route.value, __route.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_routeDistributionType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 543, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 543, 8)
id = property(__id.value, __id.set, None, None)
# Attribute last uses Python identifier last
__last = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'last'), 'last', '__AbsentNamespace0_routeDistributionType_last', pyxb.binding.datatypes.nonNegativeInteger)
__last._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 544, 8)
__last._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 544, 8)
last = property(__last.value, __last.set, None, None)
# Attribute routes uses Python identifier routes
__routes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'routes'), 'routes', '__AbsentNamespace0_routeDistributionType_routes', pyxb.binding.datatypes.string)
__routes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 545, 8)
__routes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 545, 8)
routes = property(__routes.value, __routes.set, None, None)
# Attribute probabilities uses Python identifier probabilities
__probabilities = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probabilities'), 'probabilities', '__AbsentNamespace0_routeDistributionType_probabilities', pyxb.binding.datatypes.string)
__probabilities._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 546, 8)
__probabilities._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 546, 8)
probabilities = property(__probabilities.value, __probabilities.set, None, None)
_ElementMap.update({
__route.name() : __route
})
_AttributeMap.update({
__id.name() : __id,
__last.name() : __last,
__routes.name() : __routes,
__probabilities.name() : __probabilities
})
_module_typeBindings.routeDistributionType = routeDistributionType
Namespace.addCategoryObject('typeBinding', 'routeDistributionType', routeDistributionType)
# Complex type vehicleRouteDistributionType with content type ELEMENT_ONLY
class vehicleRouteDistributionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vehicleRouteDistributionType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vehicleRouteDistributionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 549, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element route uses Python identifier route
__route = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_vehicleRouteDistributionType_route', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 551, 12), )
route = property(__route.value, __route.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_vehicleRouteDistributionType_id', pyxb.binding.datatypes.string)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 553, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 553, 8)
id = property(__id.value, __id.set, None, None)
# Attribute last uses Python identifier last
__last = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'last'), 'last', '__AbsentNamespace0_vehicleRouteDistributionType_last', pyxb.binding.datatypes.nonNegativeInteger)
__last._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 554, 8)
__last._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 554, 8)
last = property(__last.value, __last.set, None, None)
_ElementMap.update({
__route.name() : __route
})
_AttributeMap.update({
__id.name() : __id,
__last.name() : __last
})
_module_typeBindings.vehicleRouteDistributionType = vehicleRouteDistributionType
Namespace.addCategoryObject('typeBinding', 'vehicleRouteDistributionType', vehicleRouteDistributionType)
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_4 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 571, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_CTD_ANON_4_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 572, 20)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 572, 20)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_CTD_ANON_4_to', pyxb.binding.datatypes.string)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 573, 20)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 573, 20)
to = property(__to.value, __to.set, None, None)
# Attribute busStop uses Python identifier busStop
__busStop = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'busStop'), 'busStop', '__AbsentNamespace0_CTD_ANON_4_busStop', pyxb.binding.datatypes.string)
__busStop._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 574, 20)
__busStop._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 574, 20)
busStop = property(__busStop.value, __busStop.set, None, None)
# Attribute lines uses Python identifier lines
__lines = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lines'), 'lines', '__AbsentNamespace0_CTD_ANON_4_lines', pyxb.binding.datatypes.string, required=True)
__lines._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 575, 20)
__lines._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 575, 20)
lines = property(__lines.value, __lines.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_CTD_ANON_4_arrivalPos', pyxb.binding.datatypes.float)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 576, 20)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 576, 20)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute cost uses Python identifier cost
__cost = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'cost'), 'cost', '__AbsentNamespace0_CTD_ANON_4_cost', pyxb.binding.datatypes.float)
__cost._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 577, 20)
__cost._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 577, 20)
cost = property(__cost.value, __cost.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__from.name() : __from,
__to.name() : __to,
__busStop.name() : __busStop,
__lines.name() : __lines,
__arrivalPos.name() : __arrivalPos,
__cost.name() : __cost
})
_module_typeBindings.CTD_ANON_4 = CTD_ANON_4
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_5 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 612, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_CTD_ANON_5_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 613, 20)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 613, 20)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_CTD_ANON_5_to', pyxb.binding.datatypes.string, required=True)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 614, 20)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 614, 20)
to = property(__to.value, __to.set, None, None)
# Attribute lines uses Python identifier lines
__lines = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lines'), 'lines', '__AbsentNamespace0_CTD_ANON_5_lines', pyxb.binding.datatypes.string, required=True)
__lines._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 615, 20)
__lines._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 615, 20)
lines = property(__lines.value, __lines.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__from.name() : __from,
__to.name() : __to,
__lines.name() : __lines
})
_module_typeBindings.CTD_ANON_5 = CTD_ANON_5
# Complex type e1DetectorType with content type EMPTY
class e1DetectorType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type e1DetectorType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'e1DetectorType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 61, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_e1DetectorType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 62, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 62, 8)
id = property(__id.value, __id.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_e1DetectorType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 63, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 63, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_e1DetectorType_pos', pyxb.binding.datatypes.float, required=True)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 64, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 64, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_e1DetectorType_freq', _module_typeBindings.positiveFloatType, required=True)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 65, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 65, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_e1DetectorType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 66, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 66, 8)
file = property(__file.value, __file.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_e1DetectorType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 67, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 67, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_e1DetectorType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 68, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 68, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__lane.name() : __lane,
__pos.name() : __pos,
__freq.name() : __freq,
__file.name() : __file,
__vTypes.name() : __vTypes,
__friendlyPos.name() : __friendlyPos
})
_module_typeBindings.e1DetectorType = e1DetectorType
Namespace.addCategoryObject('typeBinding', 'e1DetectorType', e1DetectorType)
# Complex type vTypeProbeType with content type EMPTY
class vTypeProbeType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vTypeProbeType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vTypeProbeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 71, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_vTypeProbeType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 72, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 72, 8)
id = property(__id.value, __id.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_vTypeProbeType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 73, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 73, 8)
type = property(__type.value, __type.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_vTypeProbeType_freq', _module_typeBindings.positiveFloatType, required=True)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 74, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 74, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_vTypeProbeType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 75, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 75, 8)
file = property(__file.value, __file.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__type.name() : __type,
__freq.name() : __freq,
__file.name() : __file
})
_module_typeBindings.vTypeProbeType = vTypeProbeType
Namespace.addCategoryObject('typeBinding', 'vTypeProbeType', vTypeProbeType)
# Complex type e2DetectorType with content type EMPTY
class e2DetectorType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type e2DetectorType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'e2DetectorType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 78, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_e2DetectorType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 79, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 79, 8)
id = property(__id.value, __id.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_e2DetectorType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 80, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 80, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_e2DetectorType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 81, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 81, 8)
file = property(__file.value, __file.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_e2DetectorType_pos', pyxb.binding.datatypes.float)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 82, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 82, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute endPos uses Python identifier endPos
__endPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'endPos'), 'endPos', '__AbsentNamespace0_e2DetectorType_endPos', pyxb.binding.datatypes.float)
__endPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 83, 8)
__endPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 83, 8)
endPos = property(__endPos.value, __endPos.set, None, None)
# Attribute length uses Python identifier length
__length = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'length'), 'length', '__AbsentNamespace0_e2DetectorType_length', pyxb.binding.datatypes.float)
__length._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 84, 8)
__length._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 84, 8)
length = property(__length.value, __length.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_e2DetectorType_freq', _module_typeBindings.positiveFloatType)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 85, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 85, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute tl uses Python identifier tl
__tl = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tl'), 'tl', '__AbsentNamespace0_e2DetectorType_tl', pyxb.binding.datatypes.string)
__tl._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 86, 8)
__tl._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 86, 8)
tl = property(__tl.value, __tl.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_e2DetectorType_to', pyxb.binding.datatypes.string)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 87, 8)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 87, 8)
to = property(__to.value, __to.set, None, None)
# Attribute cont uses Python identifier cont
__cont = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'cont'), 'cont', '__AbsentNamespace0_e2DetectorType_cont', _module_typeBindings.boolType)
__cont._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 88, 8)
__cont._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 88, 8)
cont = property(__cont.value, __cont.set, None, None)
# Attribute timeThreshold uses Python identifier timeThreshold
__timeThreshold = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'timeThreshold'), 'timeThreshold', '__AbsentNamespace0_e2DetectorType_timeThreshold', pyxb.binding.datatypes.int)
__timeThreshold._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 89, 8)
__timeThreshold._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 89, 8)
timeThreshold = property(__timeThreshold.value, __timeThreshold.set, None, None)
# Attribute speedThreshold uses Python identifier speedThreshold
__speedThreshold = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speedThreshold'), 'speedThreshold', '__AbsentNamespace0_e2DetectorType_speedThreshold', pyxb.binding.datatypes.float)
__speedThreshold._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 90, 8)
__speedThreshold._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 90, 8)
speedThreshold = property(__speedThreshold.value, __speedThreshold.set, None, None)
# Attribute jamThreshold uses Python identifier jamThreshold
__jamThreshold = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jamThreshold'), 'jamThreshold', '__AbsentNamespace0_e2DetectorType_jamThreshold', pyxb.binding.datatypes.float)
__jamThreshold._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 91, 8)
__jamThreshold._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 91, 8)
jamThreshold = property(__jamThreshold.value, __jamThreshold.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_e2DetectorType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 92, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 92, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_e2DetectorType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 93, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 93, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__lane.name() : __lane,
__file.name() : __file,
__pos.name() : __pos,
__endPos.name() : __endPos,
__length.name() : __length,
__freq.name() : __freq,
__tl.name() : __tl,
__to.name() : __to,
__cont.name() : __cont,
__timeThreshold.name() : __timeThreshold,
__speedThreshold.name() : __speedThreshold,
__jamThreshold.name() : __jamThreshold,
__vTypes.name() : __vTypes,
__friendlyPos.name() : __friendlyPos
})
_module_typeBindings.e2DetectorType = e2DetectorType
Namespace.addCategoryObject('typeBinding', 'e2DetectorType', e2DetectorType)
# Complex type e3DetectorType with content type ELEMENT_ONLY
class e3DetectorType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type e3DetectorType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'e3DetectorType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 96, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element detEntry uses Python identifier detEntry
__detEntry = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'detEntry'), 'detEntry', '__AbsentNamespace0_e3DetectorType_detEntry', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 98, 12), )
detEntry = property(__detEntry.value, __detEntry.set, None, None)
# Element detExit uses Python identifier detExit
__detExit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'detExit'), 'detExit', '__AbsentNamespace0_e3DetectorType_detExit', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 100, 12), )
detExit = property(__detExit.value, __detExit.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_e3DetectorType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 103, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 103, 8)
id = property(__id.value, __id.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_e3DetectorType_freq', _module_typeBindings.positiveFloatType, required=True)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 104, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 104, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_e3DetectorType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 105, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 105, 8)
file = property(__file.value, __file.set, None, None)
# Attribute timeThreshold uses Python identifier timeThreshold
__timeThreshold = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'timeThreshold'), 'timeThreshold', '__AbsentNamespace0_e3DetectorType_timeThreshold', pyxb.binding.datatypes.float)
__timeThreshold._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 106, 8)
__timeThreshold._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 106, 8)
timeThreshold = property(__timeThreshold.value, __timeThreshold.set, None, None)
# Attribute speedThreshold uses Python identifier speedThreshold
__speedThreshold = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speedThreshold'), 'speedThreshold', '__AbsentNamespace0_e3DetectorType_speedThreshold', _module_typeBindings.nonNegativeFloatType)
__speedThreshold._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 107, 8)
__speedThreshold._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 107, 8)
speedThreshold = property(__speedThreshold.value, __speedThreshold.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_e3DetectorType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 108, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 108, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
_ElementMap.update({
__detEntry.name() : __detEntry,
__detExit.name() : __detExit
})
_AttributeMap.update({
__id.name() : __id,
__freq.name() : __freq,
__file.name() : __file,
__timeThreshold.name() : __timeThreshold,
__speedThreshold.name() : __speedThreshold,
__vTypes.name() : __vTypes
})
_module_typeBindings.e3DetectorType = e3DetectorType
Namespace.addCategoryObject('typeBinding', 'e3DetectorType', e3DetectorType)
# Complex type detEntryExitType with content type EMPTY
class detEntryExitType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type detEntryExitType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'detEntryExitType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 111, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_detEntryExitType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 112, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 112, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_detEntryExitType_pos', pyxb.binding.datatypes.float, required=True)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 113, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 113, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_detEntryExitType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 114, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 114, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__lane.name() : __lane,
__pos.name() : __pos,
__friendlyPos.name() : __friendlyPos
})
_module_typeBindings.detEntryExitType = detEntryExitType
Namespace.addCategoryObject('typeBinding', 'detEntryExitType', detEntryExitType)
# Complex type timedEventType with content type EMPTY
class timedEventType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type timedEventType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'timedEventType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 151, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_timedEventType_type', _module_typeBindings.STD_ANON_2, required=True)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 152, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 152, 8)
type = property(__type.value, __type.set, None, None)
# Attribute source uses Python identifier source
__source = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'source'), 'source', '__AbsentNamespace0_timedEventType_source', pyxb.binding.datatypes.string, required=True)
__source._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 161, 8)
__source._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 161, 8)
source = property(__source.value, __source.set, None, None)
# Attribute dest uses Python identifier dest
__dest = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'dest'), 'dest', '__AbsentNamespace0_timedEventType_dest', pyxb.binding.datatypes.string, required=True)
__dest._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 162, 8)
__dest._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 162, 8)
dest = property(__dest.value, __dest.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__type.name() : __type,
__source.name() : __source,
__dest.name() : __dest
})
_module_typeBindings.timedEventType = timedEventType
Namespace.addCategoryObject('typeBinding', 'timedEventType', timedEventType)
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_6 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 189, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute time uses Python identifier time
__time = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__AbsentNamespace0_CTD_ANON_6_time', _module_typeBindings.nonNegativeFloatType, required=True)
__time._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 190, 20)
__time._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 190, 20)
time = property(__time.value, __time.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_CTD_ANON_6_speed', pyxb.binding.datatypes.float)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 191, 20)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 191, 20)
speed = property(__speed.value, __speed.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__time.name() : __time,
__speed.name() : __speed
})
_module_typeBindings.CTD_ANON_6 = CTD_ANON_6
# Complex type routeProbeType with content type EMPTY
class routeProbeType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type routeProbeType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'routeProbeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 200, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_routeProbeType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 201, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 201, 8)
id = property(__id.value, __id.set, None, None)
# Attribute edge uses Python identifier edge
__edge = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edge'), 'edge', '__AbsentNamespace0_routeProbeType_edge', pyxb.binding.datatypes.string)
__edge._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 202, 8)
__edge._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 202, 8)
edge = property(__edge.value, __edge.set, None, None)
# Attribute begin uses Python identifier begin
__begin = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'begin'), 'begin', '__AbsentNamespace0_routeProbeType_begin', _module_typeBindings.nonNegativeFloatType)
__begin._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 203, 8)
__begin._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 203, 8)
begin = property(__begin.value, __begin.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_routeProbeType_freq', _module_typeBindings.positiveFloatType, required=True)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 204, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 204, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_routeProbeType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 205, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 205, 8)
file = property(__file.value, __file.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_routeProbeType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 206, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 206, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__edge.name() : __edge,
__begin.name() : __begin,
__freq.name() : __freq,
__file.name() : __file,
__vTypes.name() : __vTypes
})
_module_typeBindings.routeProbeType = routeProbeType
Namespace.addCategoryObject('typeBinding', 'routeProbeType', routeProbeType)
# Complex type rerouterType with content type ELEMENT_ONLY
class rerouterType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type rerouterType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'rerouterType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 209, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element interval uses Python identifier interval
__interval = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'interval'), 'interval', '__AbsentNamespace0_rerouterType_interval', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 211, 12), )
interval = property(__interval.value, __interval.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_rerouterType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 252, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 252, 8)
id = property(__id.value, __id.set, None, None)
# Attribute edges uses Python identifier edges
__edges = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edges'), 'edges', '__AbsentNamespace0_rerouterType_edges', pyxb.binding.datatypes.string)
__edges._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 253, 8)
__edges._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 253, 8)
edges = property(__edges.value, __edges.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_rerouterType_file', pyxb.binding.datatypes.string)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 254, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 254, 8)
file = property(__file.value, __file.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_rerouterType_probability', _module_typeBindings.positiveFloatType)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 255, 8)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 255, 8)
probability = property(__probability.value, __probability.set, None, None)
_ElementMap.update({
__interval.name() : __interval
})
_AttributeMap.update({
__id.name() : __id,
__edges.name() : __edges,
__file.name() : __file,
__probability.name() : __probability
})
_module_typeBindings.rerouterType = rerouterType
Namespace.addCategoryObject('typeBinding', 'rerouterType', rerouterType)
# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_7 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 212, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element closingReroute uses Python identifier closingReroute
__closingReroute = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'closingReroute'), 'closingReroute', '__AbsentNamespace0_CTD_ANON_7_closingReroute', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 214, 24), )
closingReroute = property(__closingReroute.value, __closingReroute.set, None, None)
# Element closingLaneReroute uses Python identifier closingLaneReroute
__closingLaneReroute = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'closingLaneReroute'), 'closingLaneReroute', '__AbsentNamespace0_CTD_ANON_7_closingLaneReroute', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 221, 24), )
closingLaneReroute = property(__closingLaneReroute.value, __closingLaneReroute.set, None, None)
# Element destProbReroute uses Python identifier destProbReroute
__destProbReroute = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'destProbReroute'), 'destProbReroute', '__AbsentNamespace0_CTD_ANON_7_destProbReroute', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 228, 24), )
destProbReroute = property(__destProbReroute.value, __destProbReroute.set, None, None)
# Element routeProbReroute uses Python identifier routeProbReroute
__routeProbReroute = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'routeProbReroute'), 'routeProbReroute', '__AbsentNamespace0_CTD_ANON_7_routeProbReroute', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 234, 24), )
routeProbReroute = property(__routeProbReroute.value, __routeProbReroute.set, None, None)
# Element parkingAreaReroute uses Python identifier parkingAreaReroute
__parkingAreaReroute = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'parkingAreaReroute'), 'parkingAreaReroute', '__AbsentNamespace0_CTD_ANON_7_parkingAreaReroute', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 240, 24), )
parkingAreaReroute = property(__parkingAreaReroute.value, __parkingAreaReroute.set, None, None)
# Attribute begin uses Python identifier begin
__begin = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'begin'), 'begin', '__AbsentNamespace0_CTD_ANON_7_begin', _module_typeBindings.nonNegativeFloatType, required=True)
__begin._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 247, 20)
__begin._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 247, 20)
begin = property(__begin.value, __begin.set, None, None)
# Attribute end uses Python identifier end
__end = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'end'), 'end', '__AbsentNamespace0_CTD_ANON_7_end', _module_typeBindings.nonNegativeFloatType, required=True)
__end._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 248, 20)
__end._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 248, 20)
end = property(__end.value, __end.set, None, None)
_ElementMap.update({
__closingReroute.name() : __closingReroute,
__closingLaneReroute.name() : __closingLaneReroute,
__destProbReroute.name() : __destProbReroute,
__routeProbReroute.name() : __routeProbReroute,
__parkingAreaReroute.name() : __parkingAreaReroute
})
_AttributeMap.update({
__begin.name() : __begin,
__end.name() : __end
})
_module_typeBindings.CTD_ANON_7 = CTD_ANON_7
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_8 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 229, 28)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_CTD_ANON_8_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 230, 32)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 230, 32)
id = property(__id.value, __id.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_CTD_ANON_8_probability', _module_typeBindings.positiveFloatType)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 231, 32)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 231, 32)
probability = property(__probability.value, __probability.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__probability.name() : __probability
})
_module_typeBindings.CTD_ANON_8 = CTD_ANON_8
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_9 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 235, 28)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_CTD_ANON_9_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 236, 32)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 236, 32)
id = property(__id.value, __id.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_CTD_ANON_9_probability', _module_typeBindings.positiveFloatType)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 237, 32)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 237, 32)
probability = property(__probability.value, __probability.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__probability.name() : __probability
})
_module_typeBindings.CTD_ANON_9 = CTD_ANON_9
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_10 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 241, 28)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_CTD_ANON_10_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 242, 32)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 242, 32)
id = property(__id.value, __id.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_CTD_ANON_10_probability', _module_typeBindings.positiveFloatType)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 243, 32)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 243, 32)
probability = property(__probability.value, __probability.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__probability.name() : __probability
})
_module_typeBindings.CTD_ANON_10 = CTD_ANON_10
# Complex type instantInductionLoopType with content type EMPTY
class instantInductionLoopType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type instantInductionLoopType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'instantInductionLoopType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 258, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_instantInductionLoopType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 259, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 259, 8)
id = property(__id.value, __id.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_instantInductionLoopType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 260, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 260, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_instantInductionLoopType_pos', pyxb.binding.datatypes.float, required=True)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 261, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 261, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_instantInductionLoopType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 262, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 262, 8)
file = property(__file.value, __file.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_instantInductionLoopType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 263, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 263, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__lane.name() : __lane,
__pos.name() : __pos,
__file.name() : __file,
__friendlyPos.name() : __friendlyPos
})
_module_typeBindings.instantInductionLoopType = instantInductionLoopType
Namespace.addCategoryObject('typeBinding', 'instantInductionLoopType', instantInductionLoopType)
# Complex type stoppingPlaceType with content type ELEMENT_ONLY
class stoppingPlaceType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type stoppingPlaceType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'stoppingPlaceType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 266, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element access uses Python identifier access
__access = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'access'), 'access', '__AbsentNamespace0_stoppingPlaceType_access', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 268, 12), )
access = property(__access.value, __access.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_stoppingPlaceType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 275, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 275, 8)
id = property(__id.value, __id.set, None, None)
# Attribute name uses Python identifier name
__name = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'name'), 'name', '__AbsentNamespace0_stoppingPlaceType_name', pyxb.binding.datatypes.string)
__name._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 276, 8)
__name._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 276, 8)
name = property(__name.value, __name.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_stoppingPlaceType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 277, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 277, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute startPos uses Python identifier startPos
__startPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'startPos'), 'startPos', '__AbsentNamespace0_stoppingPlaceType_startPos', pyxb.binding.datatypes.float)
__startPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 278, 8)
__startPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 278, 8)
startPos = property(__startPos.value, __startPos.set, None, None)
# Attribute endPos uses Python identifier endPos
__endPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'endPos'), 'endPos', '__AbsentNamespace0_stoppingPlaceType_endPos', pyxb.binding.datatypes.float)
__endPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 279, 8)
__endPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 279, 8)
endPos = property(__endPos.value, __endPos.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_stoppingPlaceType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 280, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 280, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
# Attribute lines uses Python identifier lines
__lines = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lines'), 'lines', '__AbsentNamespace0_stoppingPlaceType_lines', pyxb.binding.datatypes.string)
__lines._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 281, 8)
__lines._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 281, 8)
lines = property(__lines.value, __lines.set, None, None)
# Attribute power uses Python identifier power
__power = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'power'), 'power', '__AbsentNamespace0_stoppingPlaceType_power', pyxb.binding.datatypes.float)
__power._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 282, 8)
__power._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 282, 8)
power = property(__power.value, __power.set, None, None)
# Attribute efficiency uses Python identifier efficiency
__efficiency = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'efficiency'), 'efficiency', '__AbsentNamespace0_stoppingPlaceType_efficiency', pyxb.binding.datatypes.float)
__efficiency._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 283, 8)
__efficiency._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 283, 8)
efficiency = property(__efficiency.value, __efficiency.set, None, None)
# Attribute chargeInTransit uses Python identifier chargeInTransit
__chargeInTransit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'chargeInTransit'), 'chargeInTransit', '__AbsentNamespace0_stoppingPlaceType_chargeInTransit', pyxb.binding.datatypes.float)
__chargeInTransit._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 284, 8)
__chargeInTransit._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 284, 8)
chargeInTransit = property(__chargeInTransit.value, __chargeInTransit.set, None, None)
# Attribute chargeDelay uses Python identifier chargeDelay
__chargeDelay = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'chargeDelay'), 'chargeDelay', '__AbsentNamespace0_stoppingPlaceType_chargeDelay', pyxb.binding.datatypes.int)
__chargeDelay._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 285, 8)
__chargeDelay._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 285, 8)
chargeDelay = property(__chargeDelay.value, __chargeDelay.set, None, None)
_ElementMap.update({
__access.name() : __access
})
_AttributeMap.update({
__id.name() : __id,
__name.name() : __name,
__lane.name() : __lane,
__startPos.name() : __startPos,
__endPos.name() : __endPos,
__friendlyPos.name() : __friendlyPos,
__lines.name() : __lines,
__power.name() : __power,
__efficiency.name() : __efficiency,
__chargeInTransit.name() : __chargeInTransit,
__chargeDelay.name() : __chargeDelay
})
_module_typeBindings.stoppingPlaceType = stoppingPlaceType
Namespace.addCategoryObject('typeBinding', 'stoppingPlaceType', stoppingPlaceType)
# Complex type chargingStationType with content type EMPTY
class chargingStationType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type chargingStationType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'chargingStationType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 288, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_chargingStationType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 289, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 289, 8)
id = property(__id.value, __id.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_chargingStationType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 290, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 290, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute startPos uses Python identifier startPos
__startPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'startPos'), 'startPos', '__AbsentNamespace0_chargingStationType_startPos', pyxb.binding.datatypes.float)
__startPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 291, 8)
__startPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 291, 8)
startPos = property(__startPos.value, __startPos.set, None, None)
# Attribute endPos uses Python identifier endPos
__endPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'endPos'), 'endPos', '__AbsentNamespace0_chargingStationType_endPos', pyxb.binding.datatypes.float)
__endPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 292, 8)
__endPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 292, 8)
endPos = property(__endPos.value, __endPos.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_chargingStationType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 293, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 293, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
# Attribute power uses Python identifier power
__power = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'power'), 'power', '__AbsentNamespace0_chargingStationType_power', pyxb.binding.datatypes.float)
__power._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 294, 8)
__power._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 294, 8)
power = property(__power.value, __power.set, None, None)
# Attribute efficiency uses Python identifier efficiency
__efficiency = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'efficiency'), 'efficiency', '__AbsentNamespace0_chargingStationType_efficiency', pyxb.binding.datatypes.float)
__efficiency._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 295, 8)
__efficiency._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 295, 8)
efficiency = property(__efficiency.value, __efficiency.set, None, None)
# Attribute chargeInTransit uses Python identifier chargeInTransit
__chargeInTransit = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'chargeInTransit'), 'chargeInTransit', '__AbsentNamespace0_chargingStationType_chargeInTransit', pyxb.binding.datatypes.float)
__chargeInTransit._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 296, 8)
__chargeInTransit._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 296, 8)
chargeInTransit = property(__chargeInTransit.value, __chargeInTransit.set, None, None)
# Attribute chargeDelay uses Python identifier chargeDelay
__chargeDelay = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'chargeDelay'), 'chargeDelay', '__AbsentNamespace0_chargingStationType_chargeDelay', pyxb.binding.datatypes.float)
__chargeDelay._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 297, 8)
__chargeDelay._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 297, 8)
chargeDelay = property(__chargeDelay.value, __chargeDelay.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__lane.name() : __lane,
__startPos.name() : __startPos,
__endPos.name() : __endPos,
__friendlyPos.name() : __friendlyPos,
__power.name() : __power,
__efficiency.name() : __efficiency,
__chargeInTransit.name() : __chargeInTransit,
__chargeDelay.name() : __chargeDelay
})
_module_typeBindings.chargingStationType = chargingStationType
Namespace.addCategoryObject('typeBinding', 'chargingStationType', chargingStationType)
# Complex type parkingAreaType with content type ELEMENT_ONLY
class parkingAreaType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type parkingAreaType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'parkingAreaType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 300, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element space uses Python identifier space
__space = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'space'), 'space', '__AbsentNamespace0_parkingAreaType_space', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 302, 12), )
space = property(__space.value, __space.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_parkingAreaType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 304, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 304, 8)
id = property(__id.value, __id.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_parkingAreaType_lane', pyxb.binding.datatypes.string, required=True)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 305, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 305, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute roadsideCapacity uses Python identifier roadsideCapacity
__roadsideCapacity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'roadsideCapacity'), 'roadsideCapacity', '__AbsentNamespace0_parkingAreaType_roadsideCapacity', _module_typeBindings.nonNegativeIntType)
__roadsideCapacity._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 306, 8)
__roadsideCapacity._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 306, 8)
roadsideCapacity = property(__roadsideCapacity.value, __roadsideCapacity.set, None, None)
# Attribute startPos uses Python identifier startPos
__startPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'startPos'), 'startPos', '__AbsentNamespace0_parkingAreaType_startPos', pyxb.binding.datatypes.float)
__startPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 307, 8)
__startPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 307, 8)
startPos = property(__startPos.value, __startPos.set, None, None)
# Attribute endPos uses Python identifier endPos
__endPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'endPos'), 'endPos', '__AbsentNamespace0_parkingAreaType_endPos', pyxb.binding.datatypes.float)
__endPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 308, 8)
__endPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 308, 8)
endPos = property(__endPos.value, __endPos.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_parkingAreaType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 309, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 309, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
# Attribute lines uses Python identifier lines
__lines = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lines'), 'lines', '__AbsentNamespace0_parkingAreaType_lines', pyxb.binding.datatypes.string)
__lines._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 310, 8)
__lines._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 310, 8)
lines = property(__lines.value, __lines.set, None, None)
# Attribute width uses Python identifier width
__width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_parkingAreaType_width', _module_typeBindings.positiveFloatType)
__width._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 311, 8)
__width._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 311, 8)
width = property(__width.value, __width.set, None, None)
# Attribute length uses Python identifier length
__length = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'length'), 'length', '__AbsentNamespace0_parkingAreaType_length', _module_typeBindings.positiveFloatType)
__length._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 312, 8)
__length._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 312, 8)
length = property(__length.value, __length.set, None, None)
# Attribute angle uses Python identifier angle
__angle = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'angle'), 'angle', '__AbsentNamespace0_parkingAreaType_angle', pyxb.binding.datatypes.float)
__angle._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 313, 8)
__angle._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 313, 8)
angle = property(__angle.value, __angle.set, None, None)
_ElementMap.update({
__space.name() : __space
})
_AttributeMap.update({
__id.name() : __id,
__lane.name() : __lane,
__roadsideCapacity.name() : __roadsideCapacity,
__startPos.name() : __startPos,
__endPos.name() : __endPos,
__friendlyPos.name() : __friendlyPos,
__lines.name() : __lines,
__width.name() : __width,
__length.name() : __length,
__angle.name() : __angle
})
_module_typeBindings.parkingAreaType = parkingAreaType
Namespace.addCategoryObject('typeBinding', 'parkingAreaType', parkingAreaType)
# Complex type parkingSpaceType with content type EMPTY
class parkingSpaceType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type parkingSpaceType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'parkingSpaceType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 316, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute x uses Python identifier x
__x = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__AbsentNamespace0_parkingSpaceType_x', pyxb.binding.datatypes.float, required=True)
__x._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 317, 8)
__x._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 317, 8)
x = property(__x.value, __x.set, None, None)
# Attribute y uses Python identifier y
__y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__AbsentNamespace0_parkingSpaceType_y', pyxb.binding.datatypes.float, required=True)
__y._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 318, 8)
__y._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 318, 8)
y = property(__y.value, __y.set, None, None)
# Attribute z uses Python identifier z
__z = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'z'), 'z', '__AbsentNamespace0_parkingSpaceType_z', pyxb.binding.datatypes.float)
__z._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 319, 8)
__z._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 319, 8)
z = property(__z.value, __z.set, None, None)
# Attribute width uses Python identifier width
__width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_parkingSpaceType_width', _module_typeBindings.positiveFloatType)
__width._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 320, 8)
__width._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 320, 8)
width = property(__width.value, __width.set, None, None)
# Attribute length uses Python identifier length
__length = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'length'), 'length', '__AbsentNamespace0_parkingSpaceType_length', _module_typeBindings.positiveFloatType)
__length._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 321, 8)
__length._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 321, 8)
length = property(__length.value, __length.set, None, None)
# Attribute angle uses Python identifier angle
__angle = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'angle'), 'angle', '__AbsentNamespace0_parkingSpaceType_angle', pyxb.binding.datatypes.float)
__angle._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 322, 8)
__angle._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 322, 8)
angle = property(__angle.value, __angle.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__x.name() : __x,
__y.name() : __y,
__z.name() : __z,
__width.name() : __width,
__length.name() : __length,
__angle.name() : __angle
})
_module_typeBindings.parkingSpaceType = parkingSpaceType
Namespace.addCategoryObject('typeBinding', 'parkingSpaceType', parkingSpaceType)
# Complex type calibratorType with content type ELEMENT_ONLY
class calibratorType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type calibratorType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'calibratorType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 325, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element route uses Python identifier route
__route = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_calibratorType_route', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 327, 12), )
route = property(__route.value, __route.set, None, None)
# Element flow uses Python identifier flow
__flow = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'flow'), 'flow', '__AbsentNamespace0_calibratorType_flow', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 328, 12), )
flow = property(__flow.value, __flow.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_calibratorType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 330, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 330, 8)
id = property(__id.value, __id.set, None, None)
# Attribute edge uses Python identifier edge
__edge = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edge'), 'edge', '__AbsentNamespace0_calibratorType_edge', pyxb.binding.datatypes.string)
__edge._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 331, 8)
__edge._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 331, 8)
edge = property(__edge.value, __edge.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_calibratorType_lane', pyxb.binding.datatypes.string)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 332, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 332, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_calibratorType_pos', pyxb.binding.datatypes.float, required=True)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 333, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 333, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_calibratorType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 334, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 334, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_calibratorType_freq', _module_typeBindings.positiveFloatType)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 335, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 335, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_calibratorType_file', pyxb.binding.datatypes.string)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 336, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 336, 8)
file = property(__file.value, __file.set, None, None)
# Attribute output uses Python identifier output
__output = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'output'), 'output', '__AbsentNamespace0_calibratorType_output', pyxb.binding.datatypes.string)
__output._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 337, 8)
__output._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 337, 8)
output = property(__output.value, __output.set, None, None)
_ElementMap.update({
__route.name() : __route,
__flow.name() : __flow
})
_AttributeMap.update({
__id.name() : __id,
__edge.name() : __edge,
__lane.name() : __lane,
__pos.name() : __pos,
__friendlyPos.name() : __friendlyPos,
__freq.name() : __freq,
__file.name() : __file,
__output.name() : __output
})
_module_typeBindings.calibratorType = calibratorType
Namespace.addCategoryObject('typeBinding', 'calibratorType', calibratorType)
# Complex type vaporizerType with content type EMPTY
class vaporizerType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vaporizerType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vaporizerType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 340, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_vaporizerType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 341, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 341, 8)
id = property(__id.value, __id.set, None, None)
# Attribute begin uses Python identifier begin
__begin = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'begin'), 'begin', '__AbsentNamespace0_vaporizerType_begin', _module_typeBindings.nonNegativeFloatType)
__begin._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 342, 8)
__begin._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 342, 8)
begin = property(__begin.value, __begin.set, None, None)
# Attribute end uses Python identifier end
__end = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'end'), 'end', '__AbsentNamespace0_vaporizerType_end', _module_typeBindings.nonNegativeFloatType)
__end._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 343, 8)
__end._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 343, 8)
end = property(__end.value, __end.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__begin.name() : __begin,
__end.name() : __end
})
_module_typeBindings.vaporizerType = vaporizerType
Namespace.addCategoryObject('typeBinding', 'vaporizerType', vaporizerType)
# Complex type tlLogicAdditionalType with content type ELEMENT_ONLY
class tlLogicAdditionalType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type tlLogicAdditionalType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'tlLogicAdditionalType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 383, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element phase uses Python identifier phase
__phase = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'phase'), 'phase', '__AbsentNamespace0_tlLogicAdditionalType_phase', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 385, 12), )
phase = property(__phase.value, __phase.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_tlLogicAdditionalType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 386, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_tlLogicAdditionalType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 388, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 388, 8)
id = property(__id.value, __id.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_tlLogicAdditionalType_type', _module_typeBindings.tlTypeType)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 389, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 389, 8)
type = property(__type.value, __type.set, None, None)
# Attribute programID uses Python identifier programID
__programID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'programID'), 'programID', '__AbsentNamespace0_tlLogicAdditionalType_programID', pyxb.binding.datatypes.string, required=True)
__programID._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 390, 8)
__programID._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 390, 8)
programID = property(__programID.value, __programID.set, None, None)
# Attribute offset uses Python identifier offset
__offset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'offset'), 'offset', '__AbsentNamespace0_tlLogicAdditionalType_offset', pyxb.binding.datatypes.float)
__offset._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 391, 8)
__offset._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 391, 8)
offset = property(__offset.value, __offset.set, None, None)
_ElementMap.update({
__phase.name() : __phase,
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__type.name() : __type,
__programID.name() : __programID,
__offset.name() : __offset
})
_module_typeBindings.tlLogicAdditionalType = tlLogicAdditionalType
Namespace.addCategoryObject('typeBinding', 'tlLogicAdditionalType', tlLogicAdditionalType)
# Complex type locationType with content type EMPTY
class locationType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type locationType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'locationType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 117, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute netOffset uses Python identifier netOffset
__netOffset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'netOffset'), 'netOffset', '__AbsentNamespace0_locationType_netOffset', _module_typeBindings.STD_ANON_8)
__netOffset._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 118, 8)
__netOffset._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 118, 8)
netOffset = property(__netOffset.value, __netOffset.set, None, None)
# Attribute convBoundary uses Python identifier convBoundary
__convBoundary = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'convBoundary'), 'convBoundary', '__AbsentNamespace0_locationType_convBoundary', _module_typeBindings.STD_ANON_9)
__convBoundary._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 125, 8)
__convBoundary._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 125, 8)
convBoundary = property(__convBoundary.value, __convBoundary.set, None, None)
# Attribute origBoundary uses Python identifier origBoundary
__origBoundary = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'origBoundary'), 'origBoundary', '__AbsentNamespace0_locationType_origBoundary', _module_typeBindings.STD_ANON_10)
__origBoundary._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 132, 8)
__origBoundary._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 132, 8)
origBoundary = property(__origBoundary.value, __origBoundary.set, None, None)
# Attribute projParameter uses Python identifier projParameter
__projParameter = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'projParameter'), 'projParameter', '__AbsentNamespace0_locationType_projParameter', pyxb.binding.datatypes.string, required=True)
__projParameter._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 139, 8)
__projParameter._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 139, 8)
projParameter = property(__projParameter.value, __projParameter.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__netOffset.name() : __netOffset,
__convBoundary.name() : __convBoundary,
__origBoundary.name() : __origBoundary,
__projParameter.name() : __projParameter
})
_module_typeBindings.locationType = locationType
Namespace.addCategoryObject('typeBinding', 'locationType', locationType)
# Complex type boolOptionType with content type EMPTY
class boolOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type boolOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'boolOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 142, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_boolOptionType_value', _module_typeBindings.boolType, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 143, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 143, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_boolOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 144, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 144, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_boolOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 145, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 145, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_boolOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 146, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 146, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.boolOptionType = boolOptionType
Namespace.addCategoryObject('typeBinding', 'boolOptionType', boolOptionType)
# Complex type intArrayOptionType with content type EMPTY
class intArrayOptionType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type intArrayOptionType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'intArrayOptionType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 184, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute value uses Python identifier value_
__value = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'value'), 'value_', '__AbsentNamespace0_intArrayOptionType_value', _module_typeBindings.STD_ANON_11, required=True)
__value._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 185, 8)
__value._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 185, 8)
value_ = property(__value.value, __value.set, None, None)
# Attribute synonymes uses Python identifier synonymes
__synonymes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'synonymes'), 'synonymes', '__AbsentNamespace0_intArrayOptionType_synonymes', pyxb.binding.datatypes.string)
__synonymes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 192, 8)
__synonymes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 192, 8)
synonymes = property(__synonymes.value, __synonymes.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_intArrayOptionType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 193, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 193, 8)
type = property(__type.value, __type.set, None, None)
# Attribute help uses Python identifier help
__help = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'help'), 'help', '__AbsentNamespace0_intArrayOptionType_help', pyxb.binding.datatypes.string)
__help._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 194, 8)
__help._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 194, 8)
help = property(__help.value, __help.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__value.name() : __value,
__synonymes.name() : __synonymes,
__type.name() : __type,
__help.name() : __help
})
_module_typeBindings.intArrayOptionType = intArrayOptionType
Namespace.addCategoryObject('typeBinding', 'intArrayOptionType', intArrayOptionType)
# Complex type tlLogicType with content type ELEMENT_ONLY
class tlLogicType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type tlLogicType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'tlLogicType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 197, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element phase uses Python identifier phase
__phase = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'phase'), 'phase', '__AbsentNamespace0_tlLogicType_phase', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 199, 12), )
phase = property(__phase.value, __phase.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_tlLogicType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 200, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_tlLogicType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 202, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 202, 8)
id = property(__id.value, __id.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_tlLogicType_type', _module_typeBindings.tlTypeType)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 203, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 203, 8)
type = property(__type.value, __type.set, None, None)
# Attribute programID uses Python identifier programID
__programID = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'programID'), 'programID', '__AbsentNamespace0_tlLogicType_programID', pyxb.binding.datatypes.string, required=True)
__programID._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 204, 8)
__programID._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 204, 8)
programID = property(__programID.value, __programID.set, None, None)
# Attribute offset uses Python identifier offset
__offset = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'offset'), 'offset', '__AbsentNamespace0_tlLogicType_offset', pyxb.binding.datatypes.float)
__offset._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 205, 8)
__offset._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 205, 8)
offset = property(__offset.value, __offset.set, None, None)
_ElementMap.update({
__phase.name() : __phase,
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__type.name() : __type,
__programID.name() : __programID,
__offset.name() : __offset
})
_module_typeBindings.tlLogicType = tlLogicType
Namespace.addCategoryObject('typeBinding', 'tlLogicType', tlLogicType)
# Complex type phaseType with content type EMPTY
class phaseType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type phaseType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'phaseType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 217, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute duration uses Python identifier duration
__duration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'duration'), 'duration', '__AbsentNamespace0_phaseType_duration', _module_typeBindings.nonNegativeFloatType, required=True)
__duration._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 218, 8)
__duration._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 218, 8)
duration = property(__duration.value, __duration.set, None, None)
# Attribute minDur uses Python identifier minDur
__minDur = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'minDur'), 'minDur', '__AbsentNamespace0_phaseType_minDur', _module_typeBindings.nonNegativeFloatType)
__minDur._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 219, 8)
__minDur._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 219, 8)
minDur = property(__minDur.value, __minDur.set, None, None)
# Attribute maxDur uses Python identifier maxDur
__maxDur = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'maxDur'), 'maxDur', '__AbsentNamespace0_phaseType_maxDur', _module_typeBindings.nonNegativeFloatType)
__maxDur._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 220, 8)
__maxDur._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 220, 8)
maxDur = property(__maxDur.value, __maxDur.set, None, None)
# Attribute state uses Python identifier state
__state = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'state'), 'state', '__AbsentNamespace0_phaseType_state', _module_typeBindings.STD_ANON_12, required=True)
__state._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 221, 8)
__state._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 221, 8)
state = property(__state.value, __state.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__duration.name() : __duration,
__minDur.name() : __minDur,
__maxDur.name() : __maxDur,
__state.name() : __state
})
_module_typeBindings.phaseType = phaseType
Namespace.addCategoryObject('typeBinding', 'phaseType', phaseType)
# Complex type typeType with content type ELEMENT_ONLY
class typeType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type typeType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'typeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 235, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element restriction uses Python identifier restriction
__restriction = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'restriction'), 'restriction', '__AbsentNamespace0_typeType_restriction', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 237, 12), )
restriction = property(__restriction.value, __restriction.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_typeType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 239, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 239, 8)
id = property(__id.value, __id.set, None, None)
# Attribute allow uses Python identifier allow
__allow = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'allow'), 'allow', '__AbsentNamespace0_typeType_allow', pyxb.binding.datatypes.string)
__allow._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 240, 8)
__allow._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 240, 8)
allow = property(__allow.value, __allow.set, None, None)
# Attribute disallow uses Python identifier disallow
__disallow = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'disallow'), 'disallow', '__AbsentNamespace0_typeType_disallow', pyxb.binding.datatypes.string)
__disallow._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 241, 8)
__disallow._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 241, 8)
disallow = property(__disallow.value, __disallow.set, None, None)
# Attribute priority uses Python identifier priority
__priority = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'priority'), 'priority', '__AbsentNamespace0_typeType_priority', pyxb.binding.datatypes.int)
__priority._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 242, 8)
__priority._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 242, 8)
priority = property(__priority.value, __priority.set, None, None)
# Attribute numLanes uses Python identifier numLanes
__numLanes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'numLanes'), 'numLanes', '__AbsentNamespace0_typeType_numLanes', pyxb.binding.datatypes.int)
__numLanes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 243, 8)
__numLanes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 243, 8)
numLanes = property(__numLanes.value, __numLanes.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_typeType_speed', pyxb.binding.datatypes.float)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 244, 8)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 244, 8)
speed = property(__speed.value, __speed.set, None, None)
# Attribute discard uses Python identifier discard
__discard = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'discard'), 'discard', '__AbsentNamespace0_typeType_discard', _module_typeBindings.boolType)
__discard._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 245, 8)
__discard._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 245, 8)
discard = property(__discard.value, __discard.set, None, None)
# Attribute oneway uses Python identifier oneway
__oneway = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'oneway'), 'oneway', '__AbsentNamespace0_typeType_oneway', _module_typeBindings.boolType)
__oneway._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 246, 8)
__oneway._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 246, 8)
oneway = property(__oneway.value, __oneway.set, None, None)
# Attribute width uses Python identifier width
__width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_typeType_width', pyxb.binding.datatypes.float)
__width._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 247, 8)
__width._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 247, 8)
width = property(__width.value, __width.set, None, None)
# Attribute sidewalkWidth uses Python identifier sidewalkWidth
__sidewalkWidth = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sidewalkWidth'), 'sidewalkWidth', '__AbsentNamespace0_typeType_sidewalkWidth', pyxb.binding.datatypes.float)
__sidewalkWidth._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 248, 8)
__sidewalkWidth._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 248, 8)
sidewalkWidth = property(__sidewalkWidth.value, __sidewalkWidth.set, None, None)
# Attribute bikeLaneWidth uses Python identifier bikeLaneWidth
__bikeLaneWidth = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'bikeLaneWidth'), 'bikeLaneWidth', '__AbsentNamespace0_typeType_bikeLaneWidth', pyxb.binding.datatypes.float)
__bikeLaneWidth._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 249, 8)
__bikeLaneWidth._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 249, 8)
bikeLaneWidth = property(__bikeLaneWidth.value, __bikeLaneWidth.set, None, None)
_ElementMap.update({
__restriction.name() : __restriction
})
_AttributeMap.update({
__id.name() : __id,
__allow.name() : __allow,
__disallow.name() : __disallow,
__priority.name() : __priority,
__numLanes.name() : __numLanes,
__speed.name() : __speed,
__discard.name() : __discard,
__oneway.name() : __oneway,
__width.name() : __width,
__sidewalkWidth.name() : __sidewalkWidth,
__bikeLaneWidth.name() : __bikeLaneWidth
})
_module_typeBindings.typeType = typeType
Namespace.addCategoryObject('typeBinding', 'typeType', typeType)
# Complex type splitType with content type EMPTY
class splitType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type splitType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'splitType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 274, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute lanes uses Python identifier lanes
__lanes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lanes'), 'lanes', '__AbsentNamespace0_splitType_lanes', _module_typeBindings.STD_ANON_13)
__lanes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 275, 8)
__lanes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 275, 8)
lanes = property(__lanes.value, __lanes.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_splitType_pos', pyxb.binding.datatypes.float, required=True)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 282, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 282, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_splitType_speed', _module_typeBindings.positiveFloatType)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 283, 8)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 283, 8)
speed = property(__speed.value, __speed.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_splitType_type', _module_typeBindings.nodeTypeType)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 284, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 284, 8)
type = property(__type.value, __type.set, None, None)
# Attribute tl uses Python identifier tl
__tl = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tl'), 'tl', '__AbsentNamespace0_splitType_tl', pyxb.binding.datatypes.string)
__tl._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 285, 8)
__tl._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 285, 8)
tl = property(__tl.value, __tl.set, None, None)
# Attribute tlType uses Python identifier tlType
__tlType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tlType'), 'tlType', '__AbsentNamespace0_splitType_tlType', _module_typeBindings.tlTypeType)
__tlType._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 286, 8)
__tlType._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 286, 8)
tlType = property(__tlType.value, __tlType.set, None, None)
# Attribute shape uses Python identifier shape
__shape = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_splitType_shape', _module_typeBindings.shapeType)
__shape._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 287, 8)
__shape._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 287, 8)
shape = property(__shape.value, __shape.set, None, None)
# Attribute radius uses Python identifier radius
__radius = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'radius'), 'radius', '__AbsentNamespace0_splitType_radius', _module_typeBindings.nonNegativeFloatType)
__radius._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 288, 8)
__radius._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 288, 8)
radius = property(__radius.value, __radius.set, None, None)
# Attribute keepClear uses Python identifier keepClear
__keepClear = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'keepClear'), 'keepClear', '__AbsentNamespace0_splitType_keepClear', _module_typeBindings.boolType)
__keepClear._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 289, 8)
__keepClear._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 289, 8)
keepClear = property(__keepClear.value, __keepClear.set, None, None)
# Attribute idBefore uses Python identifier idBefore
__idBefore = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'idBefore'), 'idBefore', '__AbsentNamespace0_splitType_idBefore', pyxb.binding.datatypes.string)
__idBefore._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 290, 8)
__idBefore._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 290, 8)
idBefore = property(__idBefore.value, __idBefore.set, None, None)
# Attribute idAfter uses Python identifier idAfter
__idAfter = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'idAfter'), 'idAfter', '__AbsentNamespace0_splitType_idAfter', pyxb.binding.datatypes.string)
__idAfter._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 291, 8)
__idAfter._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 291, 8)
idAfter = property(__idAfter.value, __idAfter.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__lanes.name() : __lanes,
__pos.name() : __pos,
__speed.name() : __speed,
__type.name() : __type,
__tl.name() : __tl,
__tlType.name() : __tlType,
__shape.name() : __shape,
__radius.name() : __radius,
__keepClear.name() : __keepClear,
__idBefore.name() : __idBefore,
__idAfter.name() : __idAfter
})
_module_typeBindings.splitType = splitType
Namespace.addCategoryObject('typeBinding', 'splitType', splitType)
# Complex type intervalType with content type ELEMENT_ONLY
class intervalType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type intervalType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'intervalType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 6, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element edge uses Python identifier edge
__edge = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'edge'), 'edge', '__AbsentNamespace0_intervalType_edge', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 8, 12), )
edge = property(__edge.value, __edge.set, None, None)
# Attribute begin uses Python identifier begin
__begin = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'begin'), 'begin', '__AbsentNamespace0_intervalType_begin', _module_typeBindings.nonNegativeFloatType, required=True)
__begin._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 20, 8)
__begin._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 20, 8)
begin = property(__begin.value, __begin.set, None, None)
# Attribute end uses Python identifier end
__end = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'end'), 'end', '__AbsentNamespace0_intervalType_end', _module_typeBindings.nonNegativeFloatType, required=True)
__end._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 21, 8)
__end._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 21, 8)
end = property(__end.value, __end.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_intervalType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 22, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 22, 8)
id = property(__id.value, __id.set, None, None)
_ElementMap.update({
__edge.name() : __edge
})
_AttributeMap.update({
__begin.name() : __begin,
__end.name() : __end,
__id.name() : __id
})
_module_typeBindings.intervalType = intervalType
Namespace.addCategoryObject('typeBinding', 'intervalType', intervalType)
# Complex type edgeLaneDataType with content type EMPTY
class edgeLaneDataType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type edgeLaneDataType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'edgeLaneDataType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 25, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_edgeLaneDataType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 26, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 26, 8)
id = property(__id.value, __id.set, None, None)
# Attribute sampledSeconds uses Python identifier sampledSeconds
__sampledSeconds = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sampledSeconds'), 'sampledSeconds', '__AbsentNamespace0_edgeLaneDataType_sampledSeconds', _module_typeBindings.nonNegativeFloatType)
__sampledSeconds._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 27, 8)
__sampledSeconds._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 27, 8)
sampledSeconds = property(__sampledSeconds.value, __sampledSeconds.set, None, None)
# Attribute traveltime uses Python identifier traveltime
__traveltime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'traveltime'), 'traveltime', '__AbsentNamespace0_edgeLaneDataType_traveltime', _module_typeBindings.nonNegativeFloatType)
__traveltime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 28, 8)
__traveltime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 28, 8)
traveltime = property(__traveltime.value, __traveltime.set, None, None)
# Attribute overlapTraveltime uses Python identifier overlapTraveltime
__overlapTraveltime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'overlapTraveltime'), 'overlapTraveltime', '__AbsentNamespace0_edgeLaneDataType_overlapTraveltime', _module_typeBindings.nonNegativeFloatType)
__overlapTraveltime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 29, 8)
__overlapTraveltime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 29, 8)
overlapTraveltime = property(__overlapTraveltime.value, __overlapTraveltime.set, None, None)
# Attribute density uses Python identifier density
__density = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'density'), 'density', '__AbsentNamespace0_edgeLaneDataType_density', _module_typeBindings.nonNegativeFloatType)
__density._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 31, 8)
__density._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 31, 8)
density = property(__density.value, __density.set, None, None)
# Attribute occupancy uses Python identifier occupancy
__occupancy = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'occupancy'), 'occupancy', '__AbsentNamespace0_edgeLaneDataType_occupancy', _module_typeBindings.nonNegativeFloatType)
__occupancy._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 32, 8)
__occupancy._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 32, 8)
occupancy = property(__occupancy.value, __occupancy.set, None, None)
# Attribute waitingTime uses Python identifier waitingTime
__waitingTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'waitingTime'), 'waitingTime', '__AbsentNamespace0_edgeLaneDataType_waitingTime', _module_typeBindings.nonNegativeFloatType)
__waitingTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 33, 8)
__waitingTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 33, 8)
waitingTime = property(__waitingTime.value, __waitingTime.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_edgeLaneDataType_speed', _module_typeBindings.nonNegativeFloatType)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 34, 8)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 34, 8)
speed = property(__speed.value, __speed.set, None, None)
# Attribute departed uses Python identifier departed
__departed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departed'), 'departed', '__AbsentNamespace0_edgeLaneDataType_departed', pyxb.binding.datatypes.integer)
__departed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 35, 8)
__departed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 35, 8)
departed = property(__departed.value, __departed.set, None, None)
# Attribute arrived uses Python identifier arrived
__arrived = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrived'), 'arrived', '__AbsentNamespace0_edgeLaneDataType_arrived', pyxb.binding.datatypes.integer)
__arrived._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 36, 8)
__arrived._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 36, 8)
arrived = property(__arrived.value, __arrived.set, None, None)
# Attribute entered uses Python identifier entered
__entered = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'entered'), 'entered', '__AbsentNamespace0_edgeLaneDataType_entered', _module_typeBindings.nonNegativeFloatType)
__entered._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 37, 8)
__entered._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 37, 8)
entered = property(__entered.value, __entered.set, None, None)
# Attribute left uses Python identifier left
__left = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'left'), 'left', '__AbsentNamespace0_edgeLaneDataType_left', pyxb.binding.datatypes.integer)
__left._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 38, 8)
__left._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 38, 8)
left = property(__left.value, __left.set, None, None)
# Attribute laneChangedFrom uses Python identifier laneChangedFrom
__laneChangedFrom = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'laneChangedFrom'), 'laneChangedFrom', '__AbsentNamespace0_edgeLaneDataType_laneChangedFrom', pyxb.binding.datatypes.integer)
__laneChangedFrom._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 39, 8)
__laneChangedFrom._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 39, 8)
laneChangedFrom = property(__laneChangedFrom.value, __laneChangedFrom.set, None, None)
# Attribute laneChangedTo uses Python identifier laneChangedTo
__laneChangedTo = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'laneChangedTo'), 'laneChangedTo', '__AbsentNamespace0_edgeLaneDataType_laneChangedTo', pyxb.binding.datatypes.integer)
__laneChangedTo._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 40, 8)
__laneChangedTo._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 40, 8)
laneChangedTo = property(__laneChangedTo.value, __laneChangedTo.set, None, None)
# Attribute vaporized uses Python identifier vaporized
__vaporized = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vaporized'), 'vaporized', '__AbsentNamespace0_edgeLaneDataType_vaporized', pyxb.binding.datatypes.integer)
__vaporized._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 41, 8)
__vaporized._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 41, 8)
vaporized = property(__vaporized.value, __vaporized.set, None, None)
# Attribute CO_abs uses Python identifier CO_abs
__CO_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO_abs'), 'CO_abs', '__AbsentNamespace0_edgeLaneDataType_CO_abs', _module_typeBindings.nonNegativeFloatType)
__CO_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 43, 8)
__CO_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 43, 8)
CO_abs = property(__CO_abs.value, __CO_abs.set, None, None)
# Attribute CO2_abs uses Python identifier CO2_abs
__CO2_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO2_abs'), 'CO2_abs', '__AbsentNamespace0_edgeLaneDataType_CO2_abs', _module_typeBindings.nonNegativeFloatType)
__CO2_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 44, 8)
__CO2_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 44, 8)
CO2_abs = property(__CO2_abs.value, __CO2_abs.set, None, None)
# Attribute HC_abs uses Python identifier HC_abs
__HC_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'HC_abs'), 'HC_abs', '__AbsentNamespace0_edgeLaneDataType_HC_abs', _module_typeBindings.nonNegativeFloatType)
__HC_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 45, 8)
__HC_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 45, 8)
HC_abs = property(__HC_abs.value, __HC_abs.set, None, None)
# Attribute PMx_abs uses Python identifier PMx_abs
__PMx_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PMx_abs'), 'PMx_abs', '__AbsentNamespace0_edgeLaneDataType_PMx_abs', _module_typeBindings.nonNegativeFloatType)
__PMx_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 46, 8)
__PMx_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 46, 8)
PMx_abs = property(__PMx_abs.value, __PMx_abs.set, None, None)
# Attribute NOx_abs uses Python identifier NOx_abs
__NOx_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NOx_abs'), 'NOx_abs', '__AbsentNamespace0_edgeLaneDataType_NOx_abs', _module_typeBindings.nonNegativeFloatType)
__NOx_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 47, 8)
__NOx_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 47, 8)
NOx_abs = property(__NOx_abs.value, __NOx_abs.set, None, None)
# Attribute fuel_abs uses Python identifier fuel_abs
__fuel_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fuel_abs'), 'fuel_abs', '__AbsentNamespace0_edgeLaneDataType_fuel_abs', _module_typeBindings.nonNegativeFloatType)
__fuel_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 48, 8)
__fuel_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 48, 8)
fuel_abs = property(__fuel_abs.value, __fuel_abs.set, None, None)
# Attribute electricity_abs uses Python identifier electricity_abs
__electricity_abs = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'electricity_abs'), 'electricity_abs', '__AbsentNamespace0_edgeLaneDataType_electricity_abs', _module_typeBindings.nonNegativeFloatType)
__electricity_abs._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 49, 8)
__electricity_abs._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 49, 8)
electricity_abs = property(__electricity_abs.value, __electricity_abs.set, None, None)
# Attribute CO_normed uses Python identifier CO_normed
__CO_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO_normed'), 'CO_normed', '__AbsentNamespace0_edgeLaneDataType_CO_normed', _module_typeBindings.nonNegativeFloatType)
__CO_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 51, 8)
__CO_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 51, 8)
CO_normed = property(__CO_normed.value, __CO_normed.set, None, None)
# Attribute CO2_normed uses Python identifier CO2_normed
__CO2_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO2_normed'), 'CO2_normed', '__AbsentNamespace0_edgeLaneDataType_CO2_normed', _module_typeBindings.nonNegativeFloatType)
__CO2_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 52, 8)
__CO2_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 52, 8)
CO2_normed = property(__CO2_normed.value, __CO2_normed.set, None, None)
# Attribute HC_normed uses Python identifier HC_normed
__HC_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'HC_normed'), 'HC_normed', '__AbsentNamespace0_edgeLaneDataType_HC_normed', _module_typeBindings.nonNegativeFloatType)
__HC_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 53, 8)
__HC_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 53, 8)
HC_normed = property(__HC_normed.value, __HC_normed.set, None, None)
# Attribute PMx_normed uses Python identifier PMx_normed
__PMx_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PMx_normed'), 'PMx_normed', '__AbsentNamespace0_edgeLaneDataType_PMx_normed', _module_typeBindings.nonNegativeFloatType)
__PMx_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 54, 8)
__PMx_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 54, 8)
PMx_normed = property(__PMx_normed.value, __PMx_normed.set, None, None)
# Attribute NOx_normed uses Python identifier NOx_normed
__NOx_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NOx_normed'), 'NOx_normed', '__AbsentNamespace0_edgeLaneDataType_NOx_normed', _module_typeBindings.nonNegativeFloatType)
__NOx_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 55, 8)
__NOx_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 55, 8)
NOx_normed = property(__NOx_normed.value, __NOx_normed.set, None, None)
# Attribute fuel_normed uses Python identifier fuel_normed
__fuel_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fuel_normed'), 'fuel_normed', '__AbsentNamespace0_edgeLaneDataType_fuel_normed', _module_typeBindings.nonNegativeFloatType)
__fuel_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 56, 8)
__fuel_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 56, 8)
fuel_normed = property(__fuel_normed.value, __fuel_normed.set, None, None)
# Attribute electricity_normed uses Python identifier electricity_normed
__electricity_normed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'electricity_normed'), 'electricity_normed', '__AbsentNamespace0_edgeLaneDataType_electricity_normed', _module_typeBindings.nonNegativeFloatType)
__electricity_normed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 57, 8)
__electricity_normed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 57, 8)
electricity_normed = property(__electricity_normed.value, __electricity_normed.set, None, None)
# Attribute CO_perVeh uses Python identifier CO_perVeh
__CO_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO_perVeh'), 'CO_perVeh', '__AbsentNamespace0_edgeLaneDataType_CO_perVeh', _module_typeBindings.nonNegativeFloatType)
__CO_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 59, 8)
__CO_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 59, 8)
CO_perVeh = property(__CO_perVeh.value, __CO_perVeh.set, None, None)
# Attribute CO2_perVeh uses Python identifier CO2_perVeh
__CO2_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'CO2_perVeh'), 'CO2_perVeh', '__AbsentNamespace0_edgeLaneDataType_CO2_perVeh', _module_typeBindings.nonNegativeFloatType)
__CO2_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 60, 8)
__CO2_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 60, 8)
CO2_perVeh = property(__CO2_perVeh.value, __CO2_perVeh.set, None, None)
# Attribute HC_perVeh uses Python identifier HC_perVeh
__HC_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'HC_perVeh'), 'HC_perVeh', '__AbsentNamespace0_edgeLaneDataType_HC_perVeh', _module_typeBindings.nonNegativeFloatType)
__HC_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 61, 8)
__HC_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 61, 8)
HC_perVeh = property(__HC_perVeh.value, __HC_perVeh.set, None, None)
# Attribute PMx_perVeh uses Python identifier PMx_perVeh
__PMx_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'PMx_perVeh'), 'PMx_perVeh', '__AbsentNamespace0_edgeLaneDataType_PMx_perVeh', _module_typeBindings.nonNegativeFloatType)
__PMx_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 62, 8)
__PMx_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 62, 8)
PMx_perVeh = property(__PMx_perVeh.value, __PMx_perVeh.set, None, None)
# Attribute NOx_perVeh uses Python identifier NOx_perVeh
__NOx_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'NOx_perVeh'), 'NOx_perVeh', '__AbsentNamespace0_edgeLaneDataType_NOx_perVeh', _module_typeBindings.nonNegativeFloatType)
__NOx_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 63, 8)
__NOx_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 63, 8)
NOx_perVeh = property(__NOx_perVeh.value, __NOx_perVeh.set, None, None)
# Attribute fuel_perVeh uses Python identifier fuel_perVeh
__fuel_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fuel_perVeh'), 'fuel_perVeh', '__AbsentNamespace0_edgeLaneDataType_fuel_perVeh', _module_typeBindings.nonNegativeFloatType)
__fuel_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 64, 8)
__fuel_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 64, 8)
fuel_perVeh = property(__fuel_perVeh.value, __fuel_perVeh.set, None, None)
# Attribute electricity_perVeh uses Python identifier electricity_perVeh
__electricity_perVeh = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'electricity_perVeh'), 'electricity_perVeh', '__AbsentNamespace0_edgeLaneDataType_electricity_perVeh', _module_typeBindings.nonNegativeFloatType)
__electricity_perVeh._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 65, 8)
__electricity_perVeh._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 65, 8)
electricity_perVeh = property(__electricity_perVeh.value, __electricity_perVeh.set, None, None)
# Attribute noise uses Python identifier noise
__noise = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'noise'), 'noise', '__AbsentNamespace0_edgeLaneDataType_noise', _module_typeBindings.nonNegativeFloatType)
__noise._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 67, 8)
__noise._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 67, 8)
noise = property(__noise.value, __noise.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__sampledSeconds.name() : __sampledSeconds,
__traveltime.name() : __traveltime,
__overlapTraveltime.name() : __overlapTraveltime,
__density.name() : __density,
__occupancy.name() : __occupancy,
__waitingTime.name() : __waitingTime,
__speed.name() : __speed,
__departed.name() : __departed,
__arrived.name() : __arrived,
__entered.name() : __entered,
__left.name() : __left,
__laneChangedFrom.name() : __laneChangedFrom,
__laneChangedTo.name() : __laneChangedTo,
__vaporized.name() : __vaporized,
__CO_abs.name() : __CO_abs,
__CO2_abs.name() : __CO2_abs,
__HC_abs.name() : __HC_abs,
__PMx_abs.name() : __PMx_abs,
__NOx_abs.name() : __NOx_abs,
__fuel_abs.name() : __fuel_abs,
__electricity_abs.name() : __electricity_abs,
__CO_normed.name() : __CO_normed,
__CO2_normed.name() : __CO2_normed,
__HC_normed.name() : __HC_normed,
__PMx_normed.name() : __PMx_normed,
__NOx_normed.name() : __NOx_normed,
__fuel_normed.name() : __fuel_normed,
__electricity_normed.name() : __electricity_normed,
__CO_perVeh.name() : __CO_perVeh,
__CO2_perVeh.name() : __CO2_perVeh,
__HC_perVeh.name() : __HC_perVeh,
__PMx_perVeh.name() : __PMx_perVeh,
__NOx_perVeh.name() : __NOx_perVeh,
__fuel_perVeh.name() : __fuel_perVeh,
__electricity_perVeh.name() : __electricity_perVeh,
__noise.name() : __noise
})
_module_typeBindings.edgeLaneDataType = edgeLaneDataType
Namespace.addCategoryObject('typeBinding', 'edgeLaneDataType', edgeLaneDataType)
# Complex type cfIDMType with content type EMPTY
class cfIDMType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfIDMType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfIDMType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 144, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfIDMType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 145, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 145, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfIDMType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 146, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 146, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfIDMType_sigma', _module_typeBindings.STD_ANON_19)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 147, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 147, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfIDMType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 155, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 155, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute delta uses Python identifier delta
__delta = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'delta'), 'delta', '__AbsentNamespace0_cfIDMType_delta', pyxb.binding.datatypes.float)
__delta._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 156, 8)
__delta._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 156, 8)
delta = property(__delta.value, __delta.set, None, None)
# Attribute stepping uses Python identifier stepping
__stepping = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'stepping'), 'stepping', '__AbsentNamespace0_cfIDMType_stepping', _module_typeBindings.positiveIntType)
__stepping._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 157, 8)
__stepping._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 157, 8)
stepping = property(__stepping.value, __stepping.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau,
__delta.name() : __delta,
__stepping.name() : __stepping
})
_module_typeBindings.cfIDMType = cfIDMType
Namespace.addCategoryObject('typeBinding', 'cfIDMType', cfIDMType)
# Complex type cfIDMMType with content type EMPTY
class cfIDMMType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfIDMMType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfIDMMType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 160, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfIDMMType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 161, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 161, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfIDMMType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 162, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 162, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfIDMMType_sigma', _module_typeBindings.STD_ANON_20)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 163, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 163, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfIDMMType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 171, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 171, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute adaptTime uses Python identifier adaptTime
__adaptTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'adaptTime'), 'adaptTime', '__AbsentNamespace0_cfIDMMType_adaptTime', pyxb.binding.datatypes.float)
__adaptTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 172, 8)
__adaptTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 172, 8)
adaptTime = property(__adaptTime.value, __adaptTime.set, None, None)
# Attribute adaptFactor uses Python identifier adaptFactor
__adaptFactor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'adaptFactor'), 'adaptFactor', '__AbsentNamespace0_cfIDMMType_adaptFactor', pyxb.binding.datatypes.float)
__adaptFactor._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 173, 8)
__adaptFactor._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 173, 8)
adaptFactor = property(__adaptFactor.value, __adaptFactor.set, None, None)
# Attribute stepping uses Python identifier stepping
__stepping = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'stepping'), 'stepping', '__AbsentNamespace0_cfIDMMType_stepping', _module_typeBindings.positiveIntType)
__stepping._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 174, 8)
__stepping._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 174, 8)
stepping = property(__stepping.value, __stepping.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau,
__adaptTime.name() : __adaptTime,
__adaptFactor.name() : __adaptFactor,
__stepping.name() : __stepping
})
_module_typeBindings.cfIDMMType = cfIDMMType
Namespace.addCategoryObject('typeBinding', 'cfIDMMType', cfIDMMType)
# Complex type cfKraussType with content type EMPTY
class cfKraussType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfKraussType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfKraussType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 177, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfKraussType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 178, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 178, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfKraussType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 179, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 179, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfKraussType_sigma', _module_typeBindings.STD_ANON_21)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 180, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 180, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfKraussType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 188, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 188, 8)
tau = property(__tau.value, __tau.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau
})
_module_typeBindings.cfKraussType = cfKraussType
Namespace.addCategoryObject('typeBinding', 'cfKraussType', cfKraussType)
# Complex type cfSmartType with content type EMPTY
class cfSmartType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfSmartType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfSmartType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 191, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfSmartType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 192, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 192, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfSmartType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 193, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 193, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfSmartType_sigma', _module_typeBindings.STD_ANON_22)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 194, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 194, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfSmartType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 202, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 202, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute tmp1 uses Python identifier tmp1
__tmp1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp1'), 'tmp1', '__AbsentNamespace0_cfSmartType_tmp1', pyxb.binding.datatypes.float)
__tmp1._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 203, 8)
__tmp1._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 203, 8)
tmp1 = property(__tmp1.value, __tmp1.set, None, None)
# Attribute tmp2 uses Python identifier tmp2
__tmp2 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp2'), 'tmp2', '__AbsentNamespace0_cfSmartType_tmp2', pyxb.binding.datatypes.float)
__tmp2._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 204, 8)
__tmp2._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 204, 8)
tmp2 = property(__tmp2.value, __tmp2.set, None, None)
# Attribute tmp3 uses Python identifier tmp3
__tmp3 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp3'), 'tmp3', '__AbsentNamespace0_cfSmartType_tmp3', pyxb.binding.datatypes.float)
__tmp3._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 205, 8)
__tmp3._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 205, 8)
tmp3 = property(__tmp3.value, __tmp3.set, None, None)
# Attribute tmp4 uses Python identifier tmp4
__tmp4 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp4'), 'tmp4', '__AbsentNamespace0_cfSmartType_tmp4', pyxb.binding.datatypes.float)
__tmp4._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 206, 8)
__tmp4._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 206, 8)
tmp4 = property(__tmp4.value, __tmp4.set, None, None)
# Attribute tmp5 uses Python identifier tmp5
__tmp5 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp5'), 'tmp5', '__AbsentNamespace0_cfSmartType_tmp5', pyxb.binding.datatypes.float)
__tmp5._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 207, 8)
__tmp5._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 207, 8)
tmp5 = property(__tmp5.value, __tmp5.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau,
__tmp1.name() : __tmp1,
__tmp2.name() : __tmp2,
__tmp3.name() : __tmp3,
__tmp4.name() : __tmp4,
__tmp5.name() : __tmp5
})
_module_typeBindings.cfSmartType = cfSmartType
Namespace.addCategoryObject('typeBinding', 'cfSmartType', cfSmartType)
# Complex type cfPWagType with content type EMPTY
class cfPWagType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfPWagType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfPWagType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 210, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfPWagType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 211, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 211, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfPWagType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 212, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 212, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfPWagType_sigma', _module_typeBindings.STD_ANON_23)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 213, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 213, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfPWagType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 221, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 221, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute tauLast uses Python identifier tauLast
__tauLast = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tauLast'), 'tauLast', '__AbsentNamespace0_cfPWagType_tauLast', pyxb.binding.datatypes.float)
__tauLast._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 222, 8)
__tauLast._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 222, 8)
tauLast = property(__tauLast.value, __tauLast.set, None, None)
# Attribute apProb uses Python identifier apProb
__apProb = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'apProb'), 'apProb', '__AbsentNamespace0_cfPWagType_apProb', pyxb.binding.datatypes.float)
__apProb._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 223, 8)
__apProb._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 223, 8)
apProb = property(__apProb.value, __apProb.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau,
__tauLast.name() : __tauLast,
__apProb.name() : __apProb
})
_module_typeBindings.cfPWagType = cfPWagType
Namespace.addCategoryObject('typeBinding', 'cfPWagType', cfPWagType)
# Complex type cfBKernerType with content type EMPTY
class cfBKernerType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfBKernerType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfBKernerType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 226, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfBKernerType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 227, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 227, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfBKernerType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 228, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 228, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfBKernerType_sigma', _module_typeBindings.STD_ANON_24)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 229, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 229, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfBKernerType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 237, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 237, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute k uses Python identifier k
__k = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'k'), 'k', '__AbsentNamespace0_cfBKernerType_k', pyxb.binding.datatypes.float)
__k._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 238, 8)
__k._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 238, 8)
k = property(__k.value, __k.set, None, None)
# Attribute phi uses Python identifier phi
__phi = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'phi'), 'phi', '__AbsentNamespace0_cfBKernerType_phi', pyxb.binding.datatypes.float)
__phi._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 239, 8)
__phi._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 239, 8)
phi = property(__phi.value, __phi.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau,
__k.name() : __k,
__phi.name() : __phi
})
_module_typeBindings.cfBKernerType = cfBKernerType
Namespace.addCategoryObject('typeBinding', 'cfBKernerType', cfBKernerType)
# Complex type cfWiedemannType with content type EMPTY
class cfWiedemannType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type cfWiedemannType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'cfWiedemannType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 242, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_cfWiedemannType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 243, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 243, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_cfWiedemannType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 244, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 244, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_cfWiedemannType_sigma', _module_typeBindings.STD_ANON_25)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 245, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 245, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_cfWiedemannType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 253, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 253, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute security uses Python identifier security
__security = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'security'), 'security', '__AbsentNamespace0_cfWiedemannType_security', pyxb.binding.datatypes.float)
__security._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 254, 8)
__security._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 254, 8)
security = property(__security.value, __security.set, None, None)
# Attribute estimation uses Python identifier estimation
__estimation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'estimation'), 'estimation', '__AbsentNamespace0_cfWiedemannType_estimation', pyxb.binding.datatypes.float)
__estimation._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 255, 8)
__estimation._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 255, 8)
estimation = property(__estimation.value, __estimation.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__accel.name() : __accel,
__decel.name() : __decel,
__sigma.name() : __sigma,
__tau.name() : __tau,
__security.name() : __security,
__estimation.name() : __estimation
})
_module_typeBindings.cfWiedemannType = cfWiedemannType
Namespace.addCategoryObject('typeBinding', 'cfWiedemannType', cfWiedemannType)
# Complex type stopType with content type EMPTY
class stopType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type stopType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'stopType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 512, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_stopType_lane', pyxb.binding.datatypes.string)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 513, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 513, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute busStop uses Python identifier busStop
__busStop = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'busStop'), 'busStop', '__AbsentNamespace0_stopType_busStop', pyxb.binding.datatypes.string)
__busStop._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 514, 8)
__busStop._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 514, 8)
busStop = property(__busStop.value, __busStop.set, None, None)
# Attribute containerStop uses Python identifier containerStop
__containerStop = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'containerStop'), 'containerStop', '__AbsentNamespace0_stopType_containerStop', pyxb.binding.datatypes.string)
__containerStop._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 515, 8)
__containerStop._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 515, 8)
containerStop = property(__containerStop.value, __containerStop.set, None, None)
# Attribute chargingStation uses Python identifier chargingStation
__chargingStation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'chargingStation'), 'chargingStation', '__AbsentNamespace0_stopType_chargingStation', pyxb.binding.datatypes.string)
__chargingStation._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 516, 8)
__chargingStation._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 516, 8)
chargingStation = property(__chargingStation.value, __chargingStation.set, None, None)
# Attribute parkingArea uses Python identifier parkingArea
__parkingArea = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'parkingArea'), 'parkingArea', '__AbsentNamespace0_stopType_parkingArea', pyxb.binding.datatypes.string)
__parkingArea._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 517, 8)
__parkingArea._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 517, 8)
parkingArea = property(__parkingArea.value, __parkingArea.set, None, None)
# Attribute startPos uses Python identifier startPos
__startPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'startPos'), 'startPos', '__AbsentNamespace0_stopType_startPos', pyxb.binding.datatypes.float)
__startPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 518, 8)
__startPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 518, 8)
startPos = property(__startPos.value, __startPos.set, None, None)
# Attribute endPos uses Python identifier endPos
__endPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'endPos'), 'endPos', '__AbsentNamespace0_stopType_endPos', pyxb.binding.datatypes.float)
__endPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 519, 8)
__endPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 519, 8)
endPos = property(__endPos.value, __endPos.set, None, None)
# Attribute friendlyPos uses Python identifier friendlyPos
__friendlyPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'friendlyPos'), 'friendlyPos', '__AbsentNamespace0_stopType_friendlyPos', _module_typeBindings.boolType)
__friendlyPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 520, 8)
__friendlyPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 520, 8)
friendlyPos = property(__friendlyPos.value, __friendlyPos.set, None, None)
# Attribute duration uses Python identifier duration
__duration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'duration'), 'duration', '__AbsentNamespace0_stopType_duration', _module_typeBindings.nonNegativeFloatType)
__duration._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 521, 8)
__duration._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 521, 8)
duration = property(__duration.value, __duration.set, None, None)
# Attribute until uses Python identifier until
__until = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'until'), 'until', '__AbsentNamespace0_stopType_until', _module_typeBindings.nonNegativeFloatType)
__until._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 522, 8)
__until._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 522, 8)
until = property(__until.value, __until.set, None, None)
# Attribute index uses Python identifier index
__index = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'index'), 'index', '__AbsentNamespace0_stopType_index', pyxb.binding.datatypes.string)
__index._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 523, 8)
__index._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 523, 8)
index = property(__index.value, __index.set, None, None)
# Attribute parking uses Python identifier parking
__parking = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'parking'), 'parking', '__AbsentNamespace0_stopType_parking', _module_typeBindings.boolType)
__parking._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 524, 8)
__parking._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 524, 8)
parking = property(__parking.value, __parking.set, None, None)
# Attribute triggered uses Python identifier triggered
__triggered = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'triggered'), 'triggered', '__AbsentNamespace0_stopType_triggered', _module_typeBindings.boolType)
__triggered._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 525, 8)
__triggered._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 525, 8)
triggered = property(__triggered.value, __triggered.set, None, None)
# Attribute containerTriggered uses Python identifier containerTriggered
__containerTriggered = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'containerTriggered'), 'containerTriggered', '__AbsentNamespace0_stopType_containerTriggered', _module_typeBindings.boolType)
__containerTriggered._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 526, 8)
__containerTriggered._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 526, 8)
containerTriggered = property(__containerTriggered.value, __containerTriggered.set, None, None)
# Attribute expected uses Python identifier expected
__expected = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'expected'), 'expected', '__AbsentNamespace0_stopType_expected', pyxb.binding.datatypes.string)
__expected._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 527, 8)
__expected._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 527, 8)
expected = property(__expected.value, __expected.set, None, None)
# Attribute actType uses Python identifier actType
__actType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'actType'), 'actType', '__AbsentNamespace0_stopType_actType', pyxb.binding.datatypes.string)
__actType._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 528, 8)
__actType._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 528, 8)
actType = property(__actType.value, __actType.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__lane.name() : __lane,
__busStop.name() : __busStop,
__containerStop.name() : __containerStop,
__chargingStation.name() : __chargingStation,
__parkingArea.name() : __parkingArea,
__startPos.name() : __startPos,
__endPos.name() : __endPos,
__friendlyPos.name() : __friendlyPos,
__duration.name() : __duration,
__until.name() : __until,
__index.name() : __index,
__parking.name() : __parking,
__triggered.name() : __triggered,
__containerTriggered.name() : __containerTriggered,
__expected.name() : __expected,
__actType.name() : __actType
})
_module_typeBindings.stopType = stopType
Namespace.addCategoryObject('typeBinding', 'stopType', stopType)
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_11 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 619, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute edges uses Python identifier edges
__edges = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edges'), 'edges', '__AbsentNamespace0_CTD_ANON_11_edges', pyxb.binding.datatypes.string)
__edges._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 620, 20)
__edges._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 620, 20)
edges = property(__edges.value, __edges.set, None, None)
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_CTD_ANON_11_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 621, 20)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 621, 20)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_CTD_ANON_11_to', pyxb.binding.datatypes.string)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 622, 20)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 622, 20)
to = property(__to.value, __to.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_CTD_ANON_11_speed', _module_typeBindings.positiveFloatType)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 623, 20)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 623, 20)
speed = property(__speed.value, __speed.set, None, None)
# Attribute duration uses Python identifier duration
__duration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'duration'), 'duration', '__AbsentNamespace0_CTD_ANON_11_duration', _module_typeBindings.positiveFloatType)
__duration._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 624, 20)
__duration._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 624, 20)
duration = property(__duration.value, __duration.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_CTD_ANON_11_departPos', pyxb.binding.datatypes.float)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 625, 20)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 625, 20)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_CTD_ANON_11_arrivalPos', pyxb.binding.datatypes.float)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 626, 20)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 626, 20)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__edges.name() : __edges,
__from.name() : __from,
__to.name() : __to,
__speed.name() : __speed,
__duration.name() : __duration,
__departPos.name() : __departPos,
__arrivalPos.name() : __arrivalPos
})
_module_typeBindings.CTD_ANON_11 = CTD_ANON_11
# Complex type meandataType with content type EMPTY
class meandataType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type meandataType with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'meandataType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 118, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_meandataType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 119, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 119, 8)
id = property(__id.value, __id.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_meandataType_type', _module_typeBindings.STD_ANON)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 120, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 120, 8)
type = property(__type.value, __type.set, None, None)
# Attribute freq uses Python identifier freq
__freq = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'freq'), 'freq', '__AbsentNamespace0_meandataType_freq', _module_typeBindings.positiveFloatType)
__freq._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 130, 8)
__freq._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 130, 8)
freq = property(__freq.value, __freq.set, None, None)
# Attribute file uses Python identifier file
__file = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'file'), 'file', '__AbsentNamespace0_meandataType_file', pyxb.binding.datatypes.string, required=True)
__file._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 131, 8)
__file._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 131, 8)
file = property(__file.value, __file.set, None, None)
# Attribute begin uses Python identifier begin
__begin = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'begin'), 'begin', '__AbsentNamespace0_meandataType_begin', _module_typeBindings.nonNegativeFloatType)
__begin._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 132, 8)
__begin._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 132, 8)
begin = property(__begin.value, __begin.set, None, None)
# Attribute end uses Python identifier end
__end = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'end'), 'end', '__AbsentNamespace0_meandataType_end', _module_typeBindings.nonNegativeFloatType)
__end._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 133, 8)
__end._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 133, 8)
end = property(__end.value, __end.set, None, None)
# Attribute maxTraveltime uses Python identifier maxTraveltime
__maxTraveltime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'maxTraveltime'), 'maxTraveltime', '__AbsentNamespace0_meandataType_maxTraveltime', _module_typeBindings.nonNegativeFloatType)
__maxTraveltime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 134, 8)
__maxTraveltime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 134, 8)
maxTraveltime = property(__maxTraveltime.value, __maxTraveltime.set, None, None)
# Attribute excludeEmpty uses Python identifier excludeEmpty
__excludeEmpty = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'excludeEmpty'), 'excludeEmpty', '__AbsentNamespace0_meandataType_excludeEmpty', _module_typeBindings.STD_ANON_35)
__excludeEmpty._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 135, 8)
__excludeEmpty._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 135, 8)
excludeEmpty = property(__excludeEmpty.value, __excludeEmpty.set, None, None)
# Attribute withInternal uses Python identifier withInternal
__withInternal = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'withInternal'), 'withInternal', '__AbsentNamespace0_meandataType_withInternal', _module_typeBindings.boolType)
__withInternal._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 146, 8)
__withInternal._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 146, 8)
withInternal = property(__withInternal.value, __withInternal.set, None, None)
# Attribute trackVehicles uses Python identifier trackVehicles
__trackVehicles = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'trackVehicles'), 'trackVehicles', '__AbsentNamespace0_meandataType_trackVehicles', _module_typeBindings.boolType)
__trackVehicles._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 147, 8)
__trackVehicles._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 147, 8)
trackVehicles = property(__trackVehicles.value, __trackVehicles.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_meandataType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 148, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 148, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id,
__type.name() : __type,
__freq.name() : __freq,
__file.name() : __file,
__begin.name() : __begin,
__end.name() : __end,
__maxTraveltime.name() : __maxTraveltime,
__excludeEmpty.name() : __excludeEmpty,
__withInternal.name() : __withInternal,
__trackVehicles.name() : __trackVehicles,
__vTypes.name() : __vTypes
})
_module_typeBindings.meandataType = meandataType
Namespace.addCategoryObject('typeBinding', 'meandataType', meandataType)
# Complex type polygonType with content type ELEMENT_ONLY
class polygonType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type polygonType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'polygonType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 346, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_polygonType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 348, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_polygonType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 350, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 350, 8)
id = property(__id.value, __id.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_polygonType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 351, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 351, 8)
type = property(__type.value, __type.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_polygonType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 352, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 352, 8)
color = property(__color.value, __color.set, None, None)
# Attribute fill uses Python identifier fill
__fill = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fill'), 'fill', '__AbsentNamespace0_polygonType_fill', _module_typeBindings.boolType)
__fill._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 353, 8)
__fill._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 353, 8)
fill = property(__fill.value, __fill.set, None, None)
# Attribute geo uses Python identifier geo
__geo = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'geo'), 'geo', '__AbsentNamespace0_polygonType_geo', _module_typeBindings.boolType)
__geo._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 354, 8)
__geo._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 354, 8)
geo = property(__geo.value, __geo.set, None, None)
# Attribute layer uses Python identifier layer
__layer = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'layer'), 'layer', '__AbsentNamespace0_polygonType_layer', pyxb.binding.datatypes.float)
__layer._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 355, 8)
__layer._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 355, 8)
layer = property(__layer.value, __layer.set, None, None)
# Attribute shape uses Python identifier shape
__shape = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'shape'), 'shape', '__AbsentNamespace0_polygonType_shape', _module_typeBindings.shapeType, required=True)
__shape._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 356, 8)
__shape._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 356, 8)
shape = property(__shape.value, __shape.set, None, None)
# Attribute angle uses Python identifier angle
__angle = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'angle'), 'angle', '__AbsentNamespace0_polygonType_angle', pyxb.binding.datatypes.float)
__angle._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 357, 8)
__angle._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 357, 8)
angle = property(__angle.value, __angle.set, None, None)
# Attribute imgFile uses Python identifier imgFile
__imgFile = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'imgFile'), 'imgFile', '__AbsentNamespace0_polygonType_imgFile', pyxb.binding.datatypes.string)
__imgFile._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 358, 8)
__imgFile._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 358, 8)
imgFile = property(__imgFile.value, __imgFile.set, None, None)
_ElementMap.update({
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__type.name() : __type,
__color.name() : __color,
__fill.name() : __fill,
__geo.name() : __geo,
__layer.name() : __layer,
__shape.name() : __shape,
__angle.name() : __angle,
__imgFile.name() : __imgFile
})
_module_typeBindings.polygonType = polygonType
Namespace.addCategoryObject('typeBinding', 'polygonType', polygonType)
# Complex type poiType with content type ELEMENT_ONLY
class poiType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type poiType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'poiType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 361, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_poiType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 363, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_poiType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 365, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 365, 8)
id = property(__id.value, __id.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_poiType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 366, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 366, 8)
type = property(__type.value, __type.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_poiType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 367, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 367, 8)
color = property(__color.value, __color.set, None, None)
# Attribute layer uses Python identifier layer
__layer = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'layer'), 'layer', '__AbsentNamespace0_poiType_layer', pyxb.binding.datatypes.float)
__layer._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 368, 8)
__layer._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 368, 8)
layer = property(__layer.value, __layer.set, None, None)
# Attribute x uses Python identifier x
__x = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__AbsentNamespace0_poiType_x', pyxb.binding.datatypes.float)
__x._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 369, 8)
__x._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 369, 8)
x = property(__x.value, __x.set, None, None)
# Attribute y uses Python identifier y
__y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__AbsentNamespace0_poiType_y', pyxb.binding.datatypes.float)
__y._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 370, 8)
__y._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 370, 8)
y = property(__y.value, __y.set, None, None)
# Attribute lon uses Python identifier lon
__lon = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lon'), 'lon', '__AbsentNamespace0_poiType_lon', pyxb.binding.datatypes.float)
__lon._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 371, 8)
__lon._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 371, 8)
lon = property(__lon.value, __lon.set, None, None)
# Attribute lat uses Python identifier lat
__lat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lat'), 'lat', '__AbsentNamespace0_poiType_lat', pyxb.binding.datatypes.float)
__lat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 372, 8)
__lat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 372, 8)
lat = property(__lat.value, __lat.set, None, None)
# Attribute lane uses Python identifier lane
__lane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_poiType_lane', pyxb.binding.datatypes.string)
__lane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 373, 8)
__lane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 373, 8)
lane = property(__lane.value, __lane.set, None, None)
# Attribute pos uses Python identifier pos
__pos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pos'), 'pos', '__AbsentNamespace0_poiType_pos', pyxb.binding.datatypes.float)
__pos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 374, 8)
__pos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 374, 8)
pos = property(__pos.value, __pos.set, None, None)
# Attribute posLat uses Python identifier posLat
__posLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'posLat'), 'posLat', '__AbsentNamespace0_poiType_posLat', pyxb.binding.datatypes.float)
__posLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 375, 8)
__posLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 375, 8)
posLat = property(__posLat.value, __posLat.set, None, None)
# Attribute angle uses Python identifier angle
__angle = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'angle'), 'angle', '__AbsentNamespace0_poiType_angle', pyxb.binding.datatypes.float)
__angle._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 376, 8)
__angle._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 376, 8)
angle = property(__angle.value, __angle.set, None, None)
# Attribute imgFile uses Python identifier imgFile
__imgFile = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'imgFile'), 'imgFile', '__AbsentNamespace0_poiType_imgFile', pyxb.binding.datatypes.string)
__imgFile._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 377, 8)
__imgFile._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 377, 8)
imgFile = property(__imgFile.value, __imgFile.set, None, None)
# Attribute width uses Python identifier width
__width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_poiType_width', pyxb.binding.datatypes.float)
__width._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 378, 8)
__width._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 378, 8)
width = property(__width.value, __width.set, None, None)
# Attribute height uses Python identifier height
__height = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'height'), 'height', '__AbsentNamespace0_poiType_height', pyxb.binding.datatypes.float)
__height._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 379, 8)
__height._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 379, 8)
height = property(__height.value, __height.set, None, None)
_ElementMap.update({
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__type.name() : __type,
__color.name() : __color,
__layer.name() : __layer,
__x.name() : __x,
__y.name() : __y,
__lon.name() : __lon,
__lat.name() : __lat,
__lane.name() : __lane,
__pos.name() : __pos,
__posLat.name() : __posLat,
__angle.name() : __angle,
__imgFile.name() : __imgFile,
__width.name() : __width,
__height.name() : __height
})
_module_typeBindings.poiType = poiType
Namespace.addCategoryObject('typeBinding', 'poiType', poiType)
# Complex type [anonymous] with content type ELEMENT_ONLY
class CTD_ANON_12 (edgeLaneDataType):
"""Complex type [anonymous] with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 9, 16)
_ElementMap = edgeLaneDataType._ElementMap.copy()
_AttributeMap = edgeLaneDataType._AttributeMap.copy()
# Base type is edgeLaneDataType
# Element lane uses Python identifier lane
__lane = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'lane'), 'lane', '__AbsentNamespace0_CTD_ANON_12_lane', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 13, 32), )
lane = property(__lane.value, __lane.set, None, None)
# Attribute id inherited from edgeLaneDataType
# Attribute sampledSeconds inherited from edgeLaneDataType
# Attribute traveltime inherited from edgeLaneDataType
# Attribute overlapTraveltime inherited from edgeLaneDataType
# Attribute density inherited from edgeLaneDataType
# Attribute occupancy inherited from edgeLaneDataType
# Attribute waitingTime inherited from edgeLaneDataType
# Attribute speed inherited from edgeLaneDataType
# Attribute departed inherited from edgeLaneDataType
# Attribute arrived inherited from edgeLaneDataType
# Attribute entered inherited from edgeLaneDataType
# Attribute left inherited from edgeLaneDataType
# Attribute laneChangedFrom inherited from edgeLaneDataType
# Attribute laneChangedTo inherited from edgeLaneDataType
# Attribute vaporized inherited from edgeLaneDataType
# Attribute CO_abs inherited from edgeLaneDataType
# Attribute CO2_abs inherited from edgeLaneDataType
# Attribute HC_abs inherited from edgeLaneDataType
# Attribute PMx_abs inherited from edgeLaneDataType
# Attribute NOx_abs inherited from edgeLaneDataType
# Attribute fuel_abs inherited from edgeLaneDataType
# Attribute electricity_abs inherited from edgeLaneDataType
# Attribute CO_normed inherited from edgeLaneDataType
# Attribute CO2_normed inherited from edgeLaneDataType
# Attribute HC_normed inherited from edgeLaneDataType
# Attribute PMx_normed inherited from edgeLaneDataType
# Attribute NOx_normed inherited from edgeLaneDataType
# Attribute fuel_normed inherited from edgeLaneDataType
# Attribute electricity_normed inherited from edgeLaneDataType
# Attribute CO_perVeh inherited from edgeLaneDataType
# Attribute CO2_perVeh inherited from edgeLaneDataType
# Attribute HC_perVeh inherited from edgeLaneDataType
# Attribute PMx_perVeh inherited from edgeLaneDataType
# Attribute NOx_perVeh inherited from edgeLaneDataType
# Attribute fuel_perVeh inherited from edgeLaneDataType
# Attribute electricity_perVeh inherited from edgeLaneDataType
# Attribute noise inherited from edgeLaneDataType
_ElementMap.update({
__lane.name() : __lane
})
_AttributeMap.update({
})
_module_typeBindings.CTD_ANON_12 = CTD_ANON_12
# Complex type vTypeType with content type ELEMENT_ONLY
class vTypeType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vTypeType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vTypeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 6, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_vTypeType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 8, 12), )
param = property(__param.value, __param.set, None, None)
# Element carFollowing-IDM uses Python identifier carFollowing_IDM
__carFollowing_IDM = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-IDM'), 'carFollowing_IDM', '__AbsentNamespace0_vTypeType_carFollowing_IDM', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 11, 20), )
carFollowing_IDM = property(__carFollowing_IDM.value, __carFollowing_IDM.set, None, None)
# Element carFollowing-IDMM uses Python identifier carFollowing_IDMM
__carFollowing_IDMM = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-IDMM'), 'carFollowing_IDMM', '__AbsentNamespace0_vTypeType_carFollowing_IDMM', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 12, 20), )
carFollowing_IDMM = property(__carFollowing_IDMM.value, __carFollowing_IDMM.set, None, None)
# Element carFollowing-Krauss uses Python identifier carFollowing_Krauss
__carFollowing_Krauss = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-Krauss'), 'carFollowing_Krauss', '__AbsentNamespace0_vTypeType_carFollowing_Krauss', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 13, 20), )
carFollowing_Krauss = property(__carFollowing_Krauss.value, __carFollowing_Krauss.set, None, None)
# Element carFollowing-KraussPS uses Python identifier carFollowing_KraussPS
__carFollowing_KraussPS = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-KraussPS'), 'carFollowing_KraussPS', '__AbsentNamespace0_vTypeType_carFollowing_KraussPS', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 14, 20), )
carFollowing_KraussPS = property(__carFollowing_KraussPS.value, __carFollowing_KraussPS.set, None, None)
# Element carFollowing-KraussOrig1 uses Python identifier carFollowing_KraussOrig1
__carFollowing_KraussOrig1 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-KraussOrig1'), 'carFollowing_KraussOrig1', '__AbsentNamespace0_vTypeType_carFollowing_KraussOrig1', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 15, 20), )
carFollowing_KraussOrig1 = property(__carFollowing_KraussOrig1.value, __carFollowing_KraussOrig1.set, None, None)
# Element carFollowing-SmartSK uses Python identifier carFollowing_SmartSK
__carFollowing_SmartSK = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-SmartSK'), 'carFollowing_SmartSK', '__AbsentNamespace0_vTypeType_carFollowing_SmartSK', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 16, 20), )
carFollowing_SmartSK = property(__carFollowing_SmartSK.value, __carFollowing_SmartSK.set, None, None)
# Element carFollowing-Daniel1 uses Python identifier carFollowing_Daniel1
__carFollowing_Daniel1 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-Daniel1'), 'carFollowing_Daniel1', '__AbsentNamespace0_vTypeType_carFollowing_Daniel1', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 17, 20), )
carFollowing_Daniel1 = property(__carFollowing_Daniel1.value, __carFollowing_Daniel1.set, None, None)
# Element carFollowing-PWagner2009 uses Python identifier carFollowing_PWagner2009
__carFollowing_PWagner2009 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-PWagner2009'), 'carFollowing_PWagner2009', '__AbsentNamespace0_vTypeType_carFollowing_PWagner2009', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 18, 20), )
carFollowing_PWagner2009 = property(__carFollowing_PWagner2009.value, __carFollowing_PWagner2009.set, None, None)
# Element carFollowing-BKerner uses Python identifier carFollowing_BKerner
__carFollowing_BKerner = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-BKerner'), 'carFollowing_BKerner', '__AbsentNamespace0_vTypeType_carFollowing_BKerner', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 19, 20), )
carFollowing_BKerner = property(__carFollowing_BKerner.value, __carFollowing_BKerner.set, None, None)
# Element carFollowing-Wiedemann uses Python identifier carFollowing_Wiedemann
__carFollowing_Wiedemann = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'carFollowing-Wiedemann'), 'carFollowing_Wiedemann', '__AbsentNamespace0_vTypeType_carFollowing_Wiedemann', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 20, 20), )
carFollowing_Wiedemann = property(__carFollowing_Wiedemann.value, __carFollowing_Wiedemann.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_vTypeType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 25, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 25, 8)
id = property(__id.value, __id.set, None, None)
# Attribute length uses Python identifier length
__length = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'length'), 'length', '__AbsentNamespace0_vTypeType_length', _module_typeBindings.positiveFloatType)
__length._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 26, 8)
__length._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 26, 8)
length = property(__length.value, __length.set, None, None)
# Attribute minGap uses Python identifier minGap
__minGap = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'minGap'), 'minGap', '__AbsentNamespace0_vTypeType_minGap', _module_typeBindings.nonNegativeFloatType)
__minGap._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 27, 8)
__minGap._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 27, 8)
minGap = property(__minGap.value, __minGap.set, None, None)
# Attribute maxSpeed uses Python identifier maxSpeed
__maxSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'maxSpeed'), 'maxSpeed', '__AbsentNamespace0_vTypeType_maxSpeed', _module_typeBindings.positiveFloatType)
__maxSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 28, 8)
__maxSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 28, 8)
maxSpeed = property(__maxSpeed.value, __maxSpeed.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_vTypeType_probability', _module_typeBindings.nonNegativeFloatType)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 29, 8)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 29, 8)
probability = property(__probability.value, __probability.set, None, None)
# Attribute speedFactor uses Python identifier speedFactor
__speedFactor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speedFactor'), 'speedFactor', '__AbsentNamespace0_vTypeType_speedFactor', _module_typeBindings.nonNegativeDistributionType)
__speedFactor._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 30, 8)
__speedFactor._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 30, 8)
speedFactor = property(__speedFactor.value, __speedFactor.set, None, None)
# Attribute speedDev uses Python identifier speedDev
__speedDev = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speedDev'), 'speedDev', '__AbsentNamespace0_vTypeType_speedDev', _module_typeBindings.nonNegativeFloatType)
__speedDev._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 31, 8)
__speedDev._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 31, 8)
speedDev = property(__speedDev.value, __speedDev.set, None, None)
# Attribute vClass uses Python identifier vClass
__vClass = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vClass'), 'vClass', '__AbsentNamespace0_vTypeType_vClass', pyxb.binding.datatypes.string)
__vClass._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 32, 8)
__vClass._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 32, 8)
vClass = property(__vClass.value, __vClass.set, None, None)
# Attribute emissionClass uses Python identifier emissionClass
__emissionClass = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'emissionClass'), 'emissionClass', '__AbsentNamespace0_vTypeType_emissionClass', pyxb.binding.datatypes.string)
__emissionClass._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 33, 8)
__emissionClass._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 33, 8)
emissionClass = property(__emissionClass.value, __emissionClass.set, None, None)
# Attribute guiShape uses Python identifier guiShape
__guiShape = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'guiShape'), 'guiShape', '__AbsentNamespace0_vTypeType_guiShape', pyxb.binding.datatypes.string)
__guiShape._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 34, 8)
__guiShape._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 34, 8)
guiShape = property(__guiShape.value, __guiShape.set, None, None)
# Attribute width uses Python identifier width
__width = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'width'), 'width', '__AbsentNamespace0_vTypeType_width', _module_typeBindings.positiveFloatType)
__width._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 35, 8)
__width._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 35, 8)
width = property(__width.value, __width.set, None, None)
# Attribute height uses Python identifier height
__height = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'height'), 'height', '__AbsentNamespace0_vTypeType_height', _module_typeBindings.positiveFloatType)
__height._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 36, 8)
__height._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 36, 8)
height = property(__height.value, __height.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_vTypeType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 37, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 37, 8)
color = property(__color.value, __color.set, None, None)
# Attribute accel uses Python identifier accel
__accel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'accel'), 'accel', '__AbsentNamespace0_vTypeType_accel', _module_typeBindings.positiveFloatType)
__accel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 38, 8)
__accel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 38, 8)
accel = property(__accel.value, __accel.set, None, None)
# Attribute decel uses Python identifier decel
__decel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'decel'), 'decel', '__AbsentNamespace0_vTypeType_decel', _module_typeBindings.positiveFloatType)
__decel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 39, 8)
__decel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 39, 8)
decel = property(__decel.value, __decel.set, None, None)
# Attribute emergencyDecel uses Python identifier emergencyDecel
__emergencyDecel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'emergencyDecel'), 'emergencyDecel', '__AbsentNamespace0_vTypeType_emergencyDecel', _module_typeBindings.positiveFloatType)
__emergencyDecel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 40, 8)
__emergencyDecel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 40, 8)
emergencyDecel = property(__emergencyDecel.value, __emergencyDecel.set, None, None)
# Attribute apparentDecel uses Python identifier apparentDecel
__apparentDecel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'apparentDecel'), 'apparentDecel', '__AbsentNamespace0_vTypeType_apparentDecel', _module_typeBindings.positiveFloatType)
__apparentDecel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 41, 8)
__apparentDecel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 41, 8)
apparentDecel = property(__apparentDecel.value, __apparentDecel.set, None, None)
# Attribute personCapacity uses Python identifier personCapacity
__personCapacity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'personCapacity'), 'personCapacity', '__AbsentNamespace0_vTypeType_personCapacity', pyxb.binding.datatypes.nonNegativeInteger)
__personCapacity._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 42, 8)
__personCapacity._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 42, 8)
personCapacity = property(__personCapacity.value, __personCapacity.set, None, None)
# Attribute containerCapacity uses Python identifier containerCapacity
__containerCapacity = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'containerCapacity'), 'containerCapacity', '__AbsentNamespace0_vTypeType_containerCapacity', pyxb.binding.datatypes.nonNegativeInteger)
__containerCapacity._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 43, 8)
__containerCapacity._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 43, 8)
containerCapacity = property(__containerCapacity.value, __containerCapacity.set, None, None)
# Attribute boardingDuration uses Python identifier boardingDuration
__boardingDuration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'boardingDuration'), 'boardingDuration', '__AbsentNamespace0_vTypeType_boardingDuration', _module_typeBindings.nonNegativeFloatType)
__boardingDuration._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 44, 8)
__boardingDuration._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 44, 8)
boardingDuration = property(__boardingDuration.value, __boardingDuration.set, None, None)
# Attribute loadingDuration uses Python identifier loadingDuration
__loadingDuration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'loadingDuration'), 'loadingDuration', '__AbsentNamespace0_vTypeType_loadingDuration', _module_typeBindings.nonNegativeFloatType)
__loadingDuration._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 45, 8)
__loadingDuration._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 45, 8)
loadingDuration = property(__loadingDuration.value, __loadingDuration.set, None, None)
# Attribute lcStrategic uses Python identifier lcStrategic
__lcStrategic = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcStrategic'), 'lcStrategic', '__AbsentNamespace0_vTypeType_lcStrategic', pyxb.binding.datatypes.float)
__lcStrategic._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 46, 8)
__lcStrategic._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 46, 8)
lcStrategic = property(__lcStrategic.value, __lcStrategic.set, None, None)
# Attribute lcCooperative uses Python identifier lcCooperative
__lcCooperative = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcCooperative'), 'lcCooperative', '__AbsentNamespace0_vTypeType_lcCooperative', pyxb.binding.datatypes.float)
__lcCooperative._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 47, 8)
__lcCooperative._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 47, 8)
lcCooperative = property(__lcCooperative.value, __lcCooperative.set, None, None)
# Attribute lcSpeedGain uses Python identifier lcSpeedGain
__lcSpeedGain = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcSpeedGain'), 'lcSpeedGain', '__AbsentNamespace0_vTypeType_lcSpeedGain', pyxb.binding.datatypes.float)
__lcSpeedGain._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 48, 8)
__lcSpeedGain._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 48, 8)
lcSpeedGain = property(__lcSpeedGain.value, __lcSpeedGain.set, None, None)
# Attribute lcKeepRight uses Python identifier lcKeepRight
__lcKeepRight = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcKeepRight'), 'lcKeepRight', '__AbsentNamespace0_vTypeType_lcKeepRight', pyxb.binding.datatypes.float)
__lcKeepRight._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 49, 8)
__lcKeepRight._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 49, 8)
lcKeepRight = property(__lcKeepRight.value, __lcKeepRight.set, None, None)
# Attribute lcSublane uses Python identifier lcSublane
__lcSublane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcSublane'), 'lcSublane', '__AbsentNamespace0_vTypeType_lcSublane', pyxb.binding.datatypes.float)
__lcSublane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 50, 8)
__lcSublane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 50, 8)
lcSublane = property(__lcSublane.value, __lcSublane.set, None, None)
# Attribute lcPushy uses Python identifier lcPushy
__lcPushy = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcPushy'), 'lcPushy', '__AbsentNamespace0_vTypeType_lcPushy', pyxb.binding.datatypes.float)
__lcPushy._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 51, 8)
__lcPushy._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 51, 8)
lcPushy = property(__lcPushy.value, __lcPushy.set, None, None)
# Attribute lcPushyGap uses Python identifier lcPushyGap
__lcPushyGap = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcPushyGap'), 'lcPushyGap', '__AbsentNamespace0_vTypeType_lcPushyGap', _module_typeBindings.nonNegativeFloatType)
__lcPushyGap._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 52, 8)
__lcPushyGap._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 52, 8)
lcPushyGap = property(__lcPushyGap.value, __lcPushyGap.set, None, None)
# Attribute lcAssertive uses Python identifier lcAssertive
__lcAssertive = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcAssertive'), 'lcAssertive', '__AbsentNamespace0_vTypeType_lcAssertive', _module_typeBindings.positiveFloatType)
__lcAssertive._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 53, 8)
__lcAssertive._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 53, 8)
lcAssertive = property(__lcAssertive.value, __lcAssertive.set, None, None)
# Attribute lcLookaheadLeft uses Python identifier lcLookaheadLeft
__lcLookaheadLeft = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcLookaheadLeft'), 'lcLookaheadLeft', '__AbsentNamespace0_vTypeType_lcLookaheadLeft', _module_typeBindings.positiveFloatType)
__lcLookaheadLeft._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 54, 8)
__lcLookaheadLeft._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 54, 8)
lcLookaheadLeft = property(__lcLookaheadLeft.value, __lcLookaheadLeft.set, None, None)
# Attribute lcSpeedGainRight uses Python identifier lcSpeedGainRight
__lcSpeedGainRight = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'lcSpeedGainRight'), 'lcSpeedGainRight', '__AbsentNamespace0_vTypeType_lcSpeedGainRight', _module_typeBindings.positiveFloatType)
__lcSpeedGainRight._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 55, 8)
__lcSpeedGainRight._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 55, 8)
lcSpeedGainRight = property(__lcSpeedGainRight.value, __lcSpeedGainRight.set, None, None)
# Attribute maxSpeedLat uses Python identifier maxSpeedLat
__maxSpeedLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'maxSpeedLat'), 'maxSpeedLat', '__AbsentNamespace0_vTypeType_maxSpeedLat', _module_typeBindings.positiveFloatType)
__maxSpeedLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 56, 8)
__maxSpeedLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 56, 8)
maxSpeedLat = property(__maxSpeedLat.value, __maxSpeedLat.set, None, None)
# Attribute latAlignment uses Python identifier latAlignment
__latAlignment = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'latAlignment'), 'latAlignment', '__AbsentNamespace0_vTypeType_latAlignment', _module_typeBindings.STD_ANON_14)
__latAlignment._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 57, 8)
__latAlignment._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 57, 8)
latAlignment = property(__latAlignment.value, __latAlignment.set, None, None)
# Attribute actionStepLength uses Python identifier actionStepLength
__actionStepLength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'actionStepLength'), 'actionStepLength', '__AbsentNamespace0_vTypeType_actionStepLength', _module_typeBindings.positiveFloatType)
__actionStepLength._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 69, 8)
__actionStepLength._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 69, 8)
actionStepLength = property(__actionStepLength.value, __actionStepLength.set, None, None)
# Attribute minGapLat uses Python identifier minGapLat
__minGapLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'minGapLat'), 'minGapLat', '__AbsentNamespace0_vTypeType_minGapLat', _module_typeBindings.positiveFloatType)
__minGapLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 70, 8)
__minGapLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 70, 8)
minGapLat = property(__minGapLat.value, __minGapLat.set, None, None)
# Attribute jmCrossingGap uses Python identifier jmCrossingGap
__jmCrossingGap = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmCrossingGap'), 'jmCrossingGap', '__AbsentNamespace0_vTypeType_jmCrossingGap', _module_typeBindings.nonNegativeFloatType)
__jmCrossingGap._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 71, 8)
__jmCrossingGap._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 71, 8)
jmCrossingGap = property(__jmCrossingGap.value, __jmCrossingGap.set, None, None)
# Attribute jmDriveAfterRedTime uses Python identifier jmDriveAfterRedTime
__jmDriveAfterRedTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmDriveAfterRedTime'), 'jmDriveAfterRedTime', '__AbsentNamespace0_vTypeType_jmDriveAfterRedTime', _module_typeBindings.nonNegativeFloatTypeWithErrorValue)
__jmDriveAfterRedTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 72, 8)
__jmDriveAfterRedTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 72, 8)
jmDriveAfterRedTime = property(__jmDriveAfterRedTime.value, __jmDriveAfterRedTime.set, None, None)
# Attribute jmDriveRedSpeed uses Python identifier jmDriveRedSpeed
__jmDriveRedSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmDriveRedSpeed'), 'jmDriveRedSpeed', '__AbsentNamespace0_vTypeType_jmDriveRedSpeed', _module_typeBindings.nonNegativeFloatType)
__jmDriveRedSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 73, 8)
__jmDriveRedSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 73, 8)
jmDriveRedSpeed = property(__jmDriveRedSpeed.value, __jmDriveRedSpeed.set, None, None)
# Attribute jmIgnoreKeepClearTime uses Python identifier jmIgnoreKeepClearTime
__jmIgnoreKeepClearTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmIgnoreKeepClearTime'), 'jmIgnoreKeepClearTime', '__AbsentNamespace0_vTypeType_jmIgnoreKeepClearTime', _module_typeBindings.nonNegativeFloatTypeWithErrorValue)
__jmIgnoreKeepClearTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 74, 8)
__jmIgnoreKeepClearTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 74, 8)
jmIgnoreKeepClearTime = property(__jmIgnoreKeepClearTime.value, __jmIgnoreKeepClearTime.set, None, None)
# Attribute jmIgnoreFoeSpeed uses Python identifier jmIgnoreFoeSpeed
__jmIgnoreFoeSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmIgnoreFoeSpeed'), 'jmIgnoreFoeSpeed', '__AbsentNamespace0_vTypeType_jmIgnoreFoeSpeed', _module_typeBindings.nonNegativeFloatType)
__jmIgnoreFoeSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 75, 8)
__jmIgnoreFoeSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 75, 8)
jmIgnoreFoeSpeed = property(__jmIgnoreFoeSpeed.value, __jmIgnoreFoeSpeed.set, None, None)
# Attribute jmIgnoreFoeProb uses Python identifier jmIgnoreFoeProb
__jmIgnoreFoeProb = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmIgnoreFoeProb'), 'jmIgnoreFoeProb', '__AbsentNamespace0_vTypeType_jmIgnoreFoeProb', _module_typeBindings.nonNegativeFloatType)
__jmIgnoreFoeProb._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 76, 8)
__jmIgnoreFoeProb._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 76, 8)
jmIgnoreFoeProb = property(__jmIgnoreFoeProb.value, __jmIgnoreFoeProb.set, None, None)
# Attribute jmSigmaMinor uses Python identifier jmSigmaMinor
__jmSigmaMinor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmSigmaMinor'), 'jmSigmaMinor', '__AbsentNamespace0_vTypeType_jmSigmaMinor', _module_typeBindings.nonNegativeFloatType)
__jmSigmaMinor._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 77, 8)
__jmSigmaMinor._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 77, 8)
jmSigmaMinor = property(__jmSigmaMinor.value, __jmSigmaMinor.set, None, None)
# Attribute jmTimegapMinor uses Python identifier jmTimegapMinor
__jmTimegapMinor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'jmTimegapMinor'), 'jmTimegapMinor', '__AbsentNamespace0_vTypeType_jmTimegapMinor', _module_typeBindings.nonNegativeFloatType)
__jmTimegapMinor._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 78, 8)
__jmTimegapMinor._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 78, 8)
jmTimegapMinor = property(__jmTimegapMinor.value, __jmTimegapMinor.set, None, None)
# Attribute sigma uses Python identifier sigma
__sigma = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'sigma'), 'sigma', '__AbsentNamespace0_vTypeType_sigma', _module_typeBindings.STD_ANON_15)
__sigma._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 79, 8)
__sigma._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 79, 8)
sigma = property(__sigma.value, __sigma.set, None, None)
# Attribute impatience uses Python identifier impatience
__impatience = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'impatience'), 'impatience', '__AbsentNamespace0_vTypeType_impatience', _module_typeBindings.STD_ANON_36)
__impatience._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 87, 8)
__impatience._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 87, 8)
impatience = property(__impatience.value, __impatience.set, None, None)
# Attribute tau uses Python identifier tau
__tau = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tau'), 'tau', '__AbsentNamespace0_vTypeType_tau', _module_typeBindings.positiveFloatType)
__tau._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 98, 8)
__tau._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 98, 8)
tau = property(__tau.value, __tau.set, None, None)
# Attribute delta uses Python identifier delta
__delta = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'delta'), 'delta', '__AbsentNamespace0_vTypeType_delta', pyxb.binding.datatypes.float)
__delta._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 99, 8)
__delta._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 99, 8)
delta = property(__delta.value, __delta.set, None, None)
# Attribute stepping uses Python identifier stepping
__stepping = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'stepping'), 'stepping', '__AbsentNamespace0_vTypeType_stepping', _module_typeBindings.positiveIntType)
__stepping._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 100, 8)
__stepping._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 100, 8)
stepping = property(__stepping.value, __stepping.set, None, None)
# Attribute adaptTime uses Python identifier adaptTime
__adaptTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'adaptTime'), 'adaptTime', '__AbsentNamespace0_vTypeType_adaptTime', pyxb.binding.datatypes.float)
__adaptTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 101, 8)
__adaptTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 101, 8)
adaptTime = property(__adaptTime.value, __adaptTime.set, None, None)
# Attribute adaptFactor uses Python identifier adaptFactor
__adaptFactor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'adaptFactor'), 'adaptFactor', '__AbsentNamespace0_vTypeType_adaptFactor', pyxb.binding.datatypes.float)
__adaptFactor._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 102, 8)
__adaptFactor._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 102, 8)
adaptFactor = property(__adaptFactor.value, __adaptFactor.set, None, None)
# Attribute tmp1 uses Python identifier tmp1
__tmp1 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp1'), 'tmp1', '__AbsentNamespace0_vTypeType_tmp1', pyxb.binding.datatypes.float)
__tmp1._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 103, 8)
__tmp1._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 103, 8)
tmp1 = property(__tmp1.value, __tmp1.set, None, None)
# Attribute tmp2 uses Python identifier tmp2
__tmp2 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp2'), 'tmp2', '__AbsentNamespace0_vTypeType_tmp2', pyxb.binding.datatypes.float)
__tmp2._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 104, 8)
__tmp2._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 104, 8)
tmp2 = property(__tmp2.value, __tmp2.set, None, None)
# Attribute tmp3 uses Python identifier tmp3
__tmp3 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp3'), 'tmp3', '__AbsentNamespace0_vTypeType_tmp3', pyxb.binding.datatypes.float)
__tmp3._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 105, 8)
__tmp3._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 105, 8)
tmp3 = property(__tmp3.value, __tmp3.set, None, None)
# Attribute tmp4 uses Python identifier tmp4
__tmp4 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp4'), 'tmp4', '__AbsentNamespace0_vTypeType_tmp4', pyxb.binding.datatypes.float)
__tmp4._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 106, 8)
__tmp4._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 106, 8)
tmp4 = property(__tmp4.value, __tmp4.set, None, None)
# Attribute tmp5 uses Python identifier tmp5
__tmp5 = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tmp5'), 'tmp5', '__AbsentNamespace0_vTypeType_tmp5', pyxb.binding.datatypes.float)
__tmp5._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 107, 8)
__tmp5._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 107, 8)
tmp5 = property(__tmp5.value, __tmp5.set, None, None)
# Attribute tauLast uses Python identifier tauLast
__tauLast = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'tauLast'), 'tauLast', '__AbsentNamespace0_vTypeType_tauLast', pyxb.binding.datatypes.float)
__tauLast._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 108, 8)
__tauLast._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 108, 8)
tauLast = property(__tauLast.value, __tauLast.set, None, None)
# Attribute apProb uses Python identifier apProb
__apProb = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'apProb'), 'apProb', '__AbsentNamespace0_vTypeType_apProb', pyxb.binding.datatypes.float)
__apProb._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 109, 8)
__apProb._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 109, 8)
apProb = property(__apProb.value, __apProb.set, None, None)
# Attribute k uses Python identifier k
__k = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'k'), 'k', '__AbsentNamespace0_vTypeType_k', pyxb.binding.datatypes.float)
__k._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 110, 8)
__k._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 110, 8)
k = property(__k.value, __k.set, None, None)
# Attribute phi uses Python identifier phi
__phi = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'phi'), 'phi', '__AbsentNamespace0_vTypeType_phi', pyxb.binding.datatypes.float)
__phi._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 111, 8)
__phi._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 111, 8)
phi = property(__phi.value, __phi.set, None, None)
# Attribute security uses Python identifier security
__security = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'security'), 'security', '__AbsentNamespace0_vTypeType_security', pyxb.binding.datatypes.float)
__security._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 112, 8)
__security._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 112, 8)
security = property(__security.value, __security.set, None, None)
# Attribute estimation uses Python identifier estimation
__estimation = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'estimation'), 'estimation', '__AbsentNamespace0_vTypeType_estimation', pyxb.binding.datatypes.float)
__estimation._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 113, 8)
__estimation._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 113, 8)
estimation = property(__estimation.value, __estimation.set, None, None)
# Attribute carFollowModel uses Python identifier carFollowModel
__carFollowModel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'carFollowModel'), 'carFollowModel', '__AbsentNamespace0_vTypeType_carFollowModel', pyxb.binding.datatypes.string)
__carFollowModel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 114, 8)
__carFollowModel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 114, 8)
carFollowModel = property(__carFollowModel.value, __carFollowModel.set, None, None)
# Attribute trainType uses Python identifier trainType
__trainType = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'trainType'), 'trainType', '__AbsentNamespace0_vTypeType_trainType', _module_typeBindings.STD_ANON_17)
__trainType._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 115, 8)
__trainType._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 115, 8)
trainType = property(__trainType.value, __trainType.set, None, None)
# Attribute laneChangeModel uses Python identifier laneChangeModel
__laneChangeModel = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'laneChangeModel'), 'laneChangeModel', '__AbsentNamespace0_vTypeType_laneChangeModel', _module_typeBindings.STD_ANON_18)
__laneChangeModel._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 130, 8)
__laneChangeModel._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 130, 8)
laneChangeModel = property(__laneChangeModel.value, __laneChangeModel.set, None, None)
# Attribute imgFile uses Python identifier imgFile
__imgFile = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'imgFile'), 'imgFile', '__AbsentNamespace0_vTypeType_imgFile', pyxb.binding.datatypes.string)
__imgFile._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 140, 8)
__imgFile._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 140, 8)
imgFile = property(__imgFile.value, __imgFile.set, None, None)
# Attribute osgFile uses Python identifier osgFile
__osgFile = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'osgFile'), 'osgFile', '__AbsentNamespace0_vTypeType_osgFile', pyxb.binding.datatypes.string)
__osgFile._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 141, 8)
__osgFile._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 141, 8)
osgFile = property(__osgFile.value, __osgFile.set, None, None)
_ElementMap.update({
__param.name() : __param,
__carFollowing_IDM.name() : __carFollowing_IDM,
__carFollowing_IDMM.name() : __carFollowing_IDMM,
__carFollowing_Krauss.name() : __carFollowing_Krauss,
__carFollowing_KraussPS.name() : __carFollowing_KraussPS,
__carFollowing_KraussOrig1.name() : __carFollowing_KraussOrig1,
__carFollowing_SmartSK.name() : __carFollowing_SmartSK,
__carFollowing_Daniel1.name() : __carFollowing_Daniel1,
__carFollowing_PWagner2009.name() : __carFollowing_PWagner2009,
__carFollowing_BKerner.name() : __carFollowing_BKerner,
__carFollowing_Wiedemann.name() : __carFollowing_Wiedemann
})
_AttributeMap.update({
__id.name() : __id,
__length.name() : __length,
__minGap.name() : __minGap,
__maxSpeed.name() : __maxSpeed,
__probability.name() : __probability,
__speedFactor.name() : __speedFactor,
__speedDev.name() : __speedDev,
__vClass.name() : __vClass,
__emissionClass.name() : __emissionClass,
__guiShape.name() : __guiShape,
__width.name() : __width,
__height.name() : __height,
__color.name() : __color,
__accel.name() : __accel,
__decel.name() : __decel,
__emergencyDecel.name() : __emergencyDecel,
__apparentDecel.name() : __apparentDecel,
__personCapacity.name() : __personCapacity,
__containerCapacity.name() : __containerCapacity,
__boardingDuration.name() : __boardingDuration,
__loadingDuration.name() : __loadingDuration,
__lcStrategic.name() : __lcStrategic,
__lcCooperative.name() : __lcCooperative,
__lcSpeedGain.name() : __lcSpeedGain,
__lcKeepRight.name() : __lcKeepRight,
__lcSublane.name() : __lcSublane,
__lcPushy.name() : __lcPushy,
__lcPushyGap.name() : __lcPushyGap,
__lcAssertive.name() : __lcAssertive,
__lcLookaheadLeft.name() : __lcLookaheadLeft,
__lcSpeedGainRight.name() : __lcSpeedGainRight,
__maxSpeedLat.name() : __maxSpeedLat,
__latAlignment.name() : __latAlignment,
__actionStepLength.name() : __actionStepLength,
__minGapLat.name() : __minGapLat,
__jmCrossingGap.name() : __jmCrossingGap,
__jmDriveAfterRedTime.name() : __jmDriveAfterRedTime,
__jmDriveRedSpeed.name() : __jmDriveRedSpeed,
__jmIgnoreKeepClearTime.name() : __jmIgnoreKeepClearTime,
__jmIgnoreFoeSpeed.name() : __jmIgnoreFoeSpeed,
__jmIgnoreFoeProb.name() : __jmIgnoreFoeProb,
__jmSigmaMinor.name() : __jmSigmaMinor,
__jmTimegapMinor.name() : __jmTimegapMinor,
__sigma.name() : __sigma,
__impatience.name() : __impatience,
__tau.name() : __tau,
__delta.name() : __delta,
__stepping.name() : __stepping,
__adaptTime.name() : __adaptTime,
__adaptFactor.name() : __adaptFactor,
__tmp1.name() : __tmp1,
__tmp2.name() : __tmp2,
__tmp3.name() : __tmp3,
__tmp4.name() : __tmp4,
__tmp5.name() : __tmp5,
__tauLast.name() : __tauLast,
__apProb.name() : __apProb,
__k.name() : __k,
__phi.name() : __phi,
__security.name() : __security,
__estimation.name() : __estimation,
__carFollowModel.name() : __carFollowModel,
__trainType.name() : __trainType,
__laneChangeModel.name() : __laneChangeModel,
__imgFile.name() : __imgFile,
__osgFile.name() : __osgFile
})
_module_typeBindings.vTypeType = vTypeType
Namespace.addCategoryObject('typeBinding', 'vTypeType', vTypeType)
# Complex type vehicleType with content type ELEMENT_ONLY
class vehicleType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vehicleType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vehicleType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 258, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_vehicleType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 260, 12), )
param = property(__param.value, __param.set, None, None)
# Element route uses Python identifier route
__route = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_vehicleType_route', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 263, 20), )
route = property(__route.value, __route.set, None, None)
# Element routeDistribution uses Python identifier routeDistribution
__routeDistribution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'routeDistribution'), 'routeDistribution', '__AbsentNamespace0_vehicleType_routeDistribution', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 264, 20), )
routeDistribution = property(__routeDistribution.value, __routeDistribution.set, None, None)
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_vehicleType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 269, 16), )
stop = property(__stop.value, __stop.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_vehicleType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 273, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 273, 8)
id = property(__id.value, __id.set, None, None)
# Attribute route uses Python identifier route_
__route_ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'route'), 'route_', '__AbsentNamespace0_vehicleType_route_', pyxb.binding.datatypes.string)
__route_._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 274, 8)
__route_._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 274, 8)
route_ = property(__route_.value, __route_.set, None, None)
# Attribute reroute uses Python identifier reroute
__reroute = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'reroute'), 'reroute', '__AbsentNamespace0_vehicleType_reroute', _module_typeBindings.boolType)
__reroute._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 275, 8)
__reroute._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 275, 8)
reroute = property(__reroute.value, __reroute.set, None, None)
# Attribute fromTaz uses Python identifier fromTaz
__fromTaz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fromTaz'), 'fromTaz', '__AbsentNamespace0_vehicleType_fromTaz', pyxb.binding.datatypes.string)
__fromTaz._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 276, 8)
__fromTaz._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 276, 8)
fromTaz = property(__fromTaz.value, __fromTaz.set, None, None)
# Attribute toTaz uses Python identifier toTaz
__toTaz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'toTaz'), 'toTaz', '__AbsentNamespace0_vehicleType_toTaz', pyxb.binding.datatypes.string)
__toTaz._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 277, 8)
__toTaz._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 277, 8)
toTaz = property(__toTaz.value, __toTaz.set, None, None)
# Attribute via uses Python identifier via
__via = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'via'), 'via', '__AbsentNamespace0_vehicleType_via', pyxb.binding.datatypes.string)
__via._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 278, 8)
__via._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 278, 8)
via = property(__via.value, __via.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_vehicleType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 279, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 279, 8)
type = property(__type.value, __type.set, None, None)
# Attribute depart uses Python identifier depart
__depart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'depart'), 'depart', '__AbsentNamespace0_vehicleType_depart', _module_typeBindings.departType, required=True)
__depart._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 280, 8)
__depart._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 280, 8)
depart = property(__depart.value, __depart.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_vehicleType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 281, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 281, 8)
color = property(__color.value, __color.set, None, None)
# Attribute departLane uses Python identifier departLane
__departLane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departLane'), 'departLane', '__AbsentNamespace0_vehicleType_departLane', _module_typeBindings.departLaneType)
__departLane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 282, 8)
__departLane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 282, 8)
departLane = property(__departLane.value, __departLane.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_vehicleType_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 283, 8)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 283, 8)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute departSpeed uses Python identifier departSpeed
__departSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departSpeed'), 'departSpeed', '__AbsentNamespace0_vehicleType_departSpeed', _module_typeBindings.departSpeedType)
__departSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 284, 8)
__departSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 284, 8)
departSpeed = property(__departSpeed.value, __departSpeed.set, None, None)
# Attribute arrivalLane uses Python identifier arrivalLane
__arrivalLane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalLane'), 'arrivalLane', '__AbsentNamespace0_vehicleType_arrivalLane', _module_typeBindings.arrivalLaneType)
__arrivalLane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 285, 8)
__arrivalLane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 285, 8)
arrivalLane = property(__arrivalLane.value, __arrivalLane.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_vehicleType_arrivalPos', _module_typeBindings.arrivalPosType)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 286, 8)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 286, 8)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute arrivalSpeed uses Python identifier arrivalSpeed
__arrivalSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalSpeed'), 'arrivalSpeed', '__AbsentNamespace0_vehicleType_arrivalSpeed', _module_typeBindings.arrivalSpeedType)
__arrivalSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 287, 8)
__arrivalSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 287, 8)
arrivalSpeed = property(__arrivalSpeed.value, __arrivalSpeed.set, None, None)
# Attribute departPosLat uses Python identifier departPosLat
__departPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPosLat'), 'departPosLat', '__AbsentNamespace0_vehicleType_departPosLat', _module_typeBindings.departPosLatType)
__departPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 288, 8)
__departPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 288, 8)
departPosLat = property(__departPosLat.value, __departPosLat.set, None, None)
# Attribute arrivalPosLat uses Python identifier arrivalPosLat
__arrivalPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPosLat'), 'arrivalPosLat', '__AbsentNamespace0_vehicleType_arrivalPosLat', _module_typeBindings.arrivalPosLatType)
__arrivalPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 289, 8)
__arrivalPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 289, 8)
arrivalPosLat = property(__arrivalPosLat.value, __arrivalPosLat.set, None, None)
# Attribute arrival uses Python identifier arrival
__arrival = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrival'), 'arrival', '__AbsentNamespace0_vehicleType_arrival', _module_typeBindings.nonNegativeFloatType)
__arrival._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 290, 8)
__arrival._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 290, 8)
arrival = property(__arrival.value, __arrival.set, None, None)
# Attribute routeLength uses Python identifier routeLength
__routeLength = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'routeLength'), 'routeLength', '__AbsentNamespace0_vehicleType_routeLength', _module_typeBindings.nonNegativeFloatType)
__routeLength._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 291, 8)
__routeLength._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 291, 8)
routeLength = property(__routeLength.value, __routeLength.set, None, None)
# Attribute line uses Python identifier line
__line = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'line'), 'line', '__AbsentNamespace0_vehicleType_line', pyxb.binding.datatypes.string)
__line._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 292, 8)
__line._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 292, 8)
line = property(__line.value, __line.set, None, None)
# Attribute personNumber uses Python identifier personNumber
__personNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'personNumber'), 'personNumber', '__AbsentNamespace0_vehicleType_personNumber', pyxb.binding.datatypes.nonNegativeInteger)
__personNumber._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 293, 8)
__personNumber._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 293, 8)
personNumber = property(__personNumber.value, __personNumber.set, None, None)
_ElementMap.update({
__param.name() : __param,
__route.name() : __route,
__routeDistribution.name() : __routeDistribution,
__stop.name() : __stop
})
_AttributeMap.update({
__id.name() : __id,
__route_.name() : __route_,
__reroute.name() : __reroute,
__fromTaz.name() : __fromTaz,
__toTaz.name() : __toTaz,
__via.name() : __via,
__type.name() : __type,
__depart.name() : __depart,
__color.name() : __color,
__departLane.name() : __departLane,
__departPos.name() : __departPos,
__departSpeed.name() : __departSpeed,
__arrivalLane.name() : __arrivalLane,
__arrivalPos.name() : __arrivalPos,
__arrivalSpeed.name() : __arrivalSpeed,
__departPosLat.name() : __departPosLat,
__arrivalPosLat.name() : __arrivalPosLat,
__arrival.name() : __arrival,
__routeLength.name() : __routeLength,
__line.name() : __line,
__personNumber.name() : __personNumber
})
_module_typeBindings.vehicleType = vehicleType
Namespace.addCategoryObject('typeBinding', 'vehicleType', vehicleType)
# Complex type flowWithoutIDType with content type ELEMENT_ONLY
class flowWithoutIDType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type flowWithoutIDType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'flowWithoutIDType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 296, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element route uses Python identifier route
__route = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_flowWithoutIDType_route', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 299, 16), )
route = property(__route.value, __route.set, None, None)
# Element routeDistribution uses Python identifier routeDistribution
__routeDistribution = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'routeDistribution'), 'routeDistribution', '__AbsentNamespace0_flowWithoutIDType_routeDistribution', False, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 300, 16), )
routeDistribution = property(__routeDistribution.value, __routeDistribution.set, None, None)
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_flowWithoutIDType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12), )
stop = property(__stop.value, __stop.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_flowWithoutIDType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute route uses Python identifier route_
__route_ = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'route'), 'route_', '__AbsentNamespace0_flowWithoutIDType_route_', pyxb.binding.datatypes.string)
__route_._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 305, 8)
__route_._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 305, 8)
route_ = property(__route_.value, __route_.set, None, None)
# Attribute fromTaz uses Python identifier fromTaz
__fromTaz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fromTaz'), 'fromTaz', '__AbsentNamespace0_flowWithoutIDType_fromTaz', pyxb.binding.datatypes.string)
__fromTaz._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 306, 8)
__fromTaz._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 306, 8)
fromTaz = property(__fromTaz.value, __fromTaz.set, None, None)
# Attribute toTaz uses Python identifier toTaz
__toTaz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'toTaz'), 'toTaz', '__AbsentNamespace0_flowWithoutIDType_toTaz', pyxb.binding.datatypes.string)
__toTaz._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 307, 8)
__toTaz._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 307, 8)
toTaz = property(__toTaz.value, __toTaz.set, None, None)
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_flowWithoutIDType_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 308, 8)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 308, 8)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_flowWithoutIDType_to', pyxb.binding.datatypes.string)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 309, 8)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 309, 8)
to = property(__to.value, __to.set, None, None)
# Attribute via uses Python identifier via
__via = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'via'), 'via', '__AbsentNamespace0_flowWithoutIDType_via', pyxb.binding.datatypes.string)
__via._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 310, 8)
__via._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 310, 8)
via = property(__via.value, __via.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_flowWithoutIDType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 311, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 311, 8)
type = property(__type.value, __type.set, None, None)
# Attribute begin uses Python identifier begin
__begin = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'begin'), 'begin', '__AbsentNamespace0_flowWithoutIDType_begin', _module_typeBindings.nonNegativeFloatType)
__begin._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 312, 8)
__begin._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 312, 8)
begin = property(__begin.value, __begin.set, None, None)
# Attribute end uses Python identifier end
__end = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'end'), 'end', '__AbsentNamespace0_flowWithoutIDType_end', _module_typeBindings.nonNegativeFloatType)
__end._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 313, 8)
__end._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 313, 8)
end = property(__end.value, __end.set, None, None)
# Attribute period uses Python identifier period
__period = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'period'), 'period', '__AbsentNamespace0_flowWithoutIDType_period', _module_typeBindings.positiveFloatType)
__period._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 314, 8)
__period._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 314, 8)
period = property(__period.value, __period.set, None, None)
# Attribute vehsPerHour uses Python identifier vehsPerHour
__vehsPerHour = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vehsPerHour'), 'vehsPerHour', '__AbsentNamespace0_flowWithoutIDType_vehsPerHour', _module_typeBindings.nonNegativeFloatType)
__vehsPerHour._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 315, 8)
__vehsPerHour._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 315, 8)
vehsPerHour = property(__vehsPerHour.value, __vehsPerHour.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_flowWithoutIDType_probability', _module_typeBindings.nonNegativeFloatType)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 316, 8)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 316, 8)
probability = property(__probability.value, __probability.set, None, None)
# Attribute number uses Python identifier number
__number = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'number'), 'number', '__AbsentNamespace0_flowWithoutIDType_number', pyxb.binding.datatypes.int)
__number._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 317, 8)
__number._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 317, 8)
number = property(__number.value, __number.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_flowWithoutIDType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 318, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 318, 8)
color = property(__color.value, __color.set, None, None)
# Attribute departLane uses Python identifier departLane
__departLane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departLane'), 'departLane', '__AbsentNamespace0_flowWithoutIDType_departLane', _module_typeBindings.departLaneType)
__departLane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 319, 8)
__departLane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 319, 8)
departLane = property(__departLane.value, __departLane.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_flowWithoutIDType_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 320, 8)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 320, 8)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute departSpeed uses Python identifier departSpeed
__departSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departSpeed'), 'departSpeed', '__AbsentNamespace0_flowWithoutIDType_departSpeed', _module_typeBindings.departSpeedType)
__departSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 321, 8)
__departSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 321, 8)
departSpeed = property(__departSpeed.value, __departSpeed.set, None, None)
# Attribute arrivalLane uses Python identifier arrivalLane
__arrivalLane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalLane'), 'arrivalLane', '__AbsentNamespace0_flowWithoutIDType_arrivalLane', _module_typeBindings.arrivalLaneType)
__arrivalLane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 322, 8)
__arrivalLane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 322, 8)
arrivalLane = property(__arrivalLane.value, __arrivalLane.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_flowWithoutIDType_arrivalPos', _module_typeBindings.arrivalPosType)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 323, 8)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 323, 8)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute arrivalSpeed uses Python identifier arrivalSpeed
__arrivalSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalSpeed'), 'arrivalSpeed', '__AbsentNamespace0_flowWithoutIDType_arrivalSpeed', _module_typeBindings.arrivalSpeedType)
__arrivalSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 324, 8)
__arrivalSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 324, 8)
arrivalSpeed = property(__arrivalSpeed.value, __arrivalSpeed.set, None, None)
# Attribute departPosLat uses Python identifier departPosLat
__departPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPosLat'), 'departPosLat', '__AbsentNamespace0_flowWithoutIDType_departPosLat', _module_typeBindings.departPosLatType)
__departPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 325, 8)
__departPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 325, 8)
departPosLat = property(__departPosLat.value, __departPosLat.set, None, None)
# Attribute arrivalPosLat uses Python identifier arrivalPosLat
__arrivalPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPosLat'), 'arrivalPosLat', '__AbsentNamespace0_flowWithoutIDType_arrivalPosLat', _module_typeBindings.arrivalPosLatType)
__arrivalPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 326, 8)
__arrivalPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 326, 8)
arrivalPosLat = property(__arrivalPosLat.value, __arrivalPosLat.set, None, None)
# Attribute line uses Python identifier line
__line = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'line'), 'line', '__AbsentNamespace0_flowWithoutIDType_line', pyxb.binding.datatypes.string)
__line._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 327, 8)
__line._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 327, 8)
line = property(__line.value, __line.set, None, None)
# Attribute personNumber uses Python identifier personNumber
__personNumber = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'personNumber'), 'personNumber', '__AbsentNamespace0_flowWithoutIDType_personNumber', pyxb.binding.datatypes.nonNegativeInteger)
__personNumber._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 328, 8)
__personNumber._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 328, 8)
personNumber = property(__personNumber.value, __personNumber.set, None, None)
_ElementMap.update({
__route.name() : __route,
__routeDistribution.name() : __routeDistribution,
__stop.name() : __stop,
__param.name() : __param
})
_AttributeMap.update({
__route_.name() : __route_,
__fromTaz.name() : __fromTaz,
__toTaz.name() : __toTaz,
__from.name() : __from,
__to.name() : __to,
__via.name() : __via,
__type.name() : __type,
__begin.name() : __begin,
__end.name() : __end,
__period.name() : __period,
__vehsPerHour.name() : __vehsPerHour,
__probability.name() : __probability,
__number.name() : __number,
__color.name() : __color,
__departLane.name() : __departLane,
__departPos.name() : __departPos,
__departSpeed.name() : __departSpeed,
__arrivalLane.name() : __arrivalLane,
__arrivalPos.name() : __arrivalPos,
__arrivalSpeed.name() : __arrivalSpeed,
__departPosLat.name() : __departPosLat,
__arrivalPosLat.name() : __arrivalPosLat,
__line.name() : __line,
__personNumber.name() : __personNumber
})
_module_typeBindings.flowWithoutIDType = flowWithoutIDType
Namespace.addCategoryObject('typeBinding', 'flowWithoutIDType', flowWithoutIDType)
# Complex type tripType with content type ELEMENT_ONLY
class tripType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type tripType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'tripType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 347, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_tripType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 349, 12), )
stop = property(__stop.value, __stop.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_tripType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 350, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_tripType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 352, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 352, 8)
id = property(__id.value, __id.set, None, None)
# Attribute fromTaz uses Python identifier fromTaz
__fromTaz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'fromTaz'), 'fromTaz', '__AbsentNamespace0_tripType_fromTaz', pyxb.binding.datatypes.string)
__fromTaz._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 353, 8)
__fromTaz._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 353, 8)
fromTaz = property(__fromTaz.value, __fromTaz.set, None, None)
# Attribute toTaz uses Python identifier toTaz
__toTaz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'toTaz'), 'toTaz', '__AbsentNamespace0_tripType_toTaz', pyxb.binding.datatypes.string)
__toTaz._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 354, 8)
__toTaz._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 354, 8)
toTaz = property(__toTaz.value, __toTaz.set, None, None)
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_tripType_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 355, 8)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 355, 8)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_tripType_to', pyxb.binding.datatypes.string)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 356, 8)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 356, 8)
to = property(__to.value, __to.set, None, None)
# Attribute via uses Python identifier via
__via = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'via'), 'via', '__AbsentNamespace0_tripType_via', pyxb.binding.datatypes.string)
__via._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 357, 8)
__via._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 357, 8)
via = property(__via.value, __via.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_tripType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 358, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 358, 8)
type = property(__type.value, __type.set, None, None)
# Attribute depart uses Python identifier depart
__depart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'depart'), 'depart', '__AbsentNamespace0_tripType_depart', _module_typeBindings.departType, required=True)
__depart._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 359, 8)
__depart._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 359, 8)
depart = property(__depart.value, __depart.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_tripType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 360, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 360, 8)
color = property(__color.value, __color.set, None, None)
# Attribute departLane uses Python identifier departLane
__departLane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departLane'), 'departLane', '__AbsentNamespace0_tripType_departLane', _module_typeBindings.departLaneType)
__departLane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 361, 8)
__departLane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 361, 8)
departLane = property(__departLane.value, __departLane.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_tripType_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 362, 8)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 362, 8)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute departSpeed uses Python identifier departSpeed
__departSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departSpeed'), 'departSpeed', '__AbsentNamespace0_tripType_departSpeed', _module_typeBindings.departSpeedType)
__departSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 363, 8)
__departSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 363, 8)
departSpeed = property(__departSpeed.value, __departSpeed.set, None, None)
# Attribute arrivalLane uses Python identifier arrivalLane
__arrivalLane = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalLane'), 'arrivalLane', '__AbsentNamespace0_tripType_arrivalLane', _module_typeBindings.arrivalLaneType)
__arrivalLane._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 364, 8)
__arrivalLane._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 364, 8)
arrivalLane = property(__arrivalLane.value, __arrivalLane.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_tripType_arrivalPos', _module_typeBindings.arrivalPosType)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 365, 8)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 365, 8)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute arrivalSpeed uses Python identifier arrivalSpeed
__arrivalSpeed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalSpeed'), 'arrivalSpeed', '__AbsentNamespace0_tripType_arrivalSpeed', _module_typeBindings.arrivalSpeedType)
__arrivalSpeed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 366, 8)
__arrivalSpeed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 366, 8)
arrivalSpeed = property(__arrivalSpeed.value, __arrivalSpeed.set, None, None)
# Attribute departPosLat uses Python identifier departPosLat
__departPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPosLat'), 'departPosLat', '__AbsentNamespace0_tripType_departPosLat', _module_typeBindings.departPosLatType)
__departPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 367, 8)
__departPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 367, 8)
departPosLat = property(__departPosLat.value, __departPosLat.set, None, None)
# Attribute arrivalPosLat uses Python identifier arrivalPosLat
__arrivalPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPosLat'), 'arrivalPosLat', '__AbsentNamespace0_tripType_arrivalPosLat', _module_typeBindings.arrivalPosLatType)
__arrivalPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 368, 8)
__arrivalPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 368, 8)
arrivalPosLat = property(__arrivalPosLat.value, __arrivalPosLat.set, None, None)
_ElementMap.update({
__stop.name() : __stop,
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__fromTaz.name() : __fromTaz,
__toTaz.name() : __toTaz,
__from.name() : __from,
__to.name() : __to,
__via.name() : __via,
__type.name() : __type,
__depart.name() : __depart,
__color.name() : __color,
__departLane.name() : __departLane,
__departPos.name() : __departPos,
__departSpeed.name() : __departSpeed,
__arrivalLane.name() : __arrivalLane,
__arrivalPos.name() : __arrivalPos,
__arrivalSpeed.name() : __arrivalSpeed,
__departPosLat.name() : __departPosLat,
__arrivalPosLat.name() : __arrivalPosLat
})
_module_typeBindings.tripType = tripType
Namespace.addCategoryObject('typeBinding', 'tripType', tripType)
# Complex type vehicleRouteType with content type ELEMENT_ONLY
class vehicleRouteType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type vehicleRouteType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'vehicleRouteType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 487, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_vehicleRouteType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 489, 12), )
stop = property(__stop.value, __stop.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_vehicleRouteType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 490, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute edges uses Python identifier edges
__edges = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edges'), 'edges', '__AbsentNamespace0_vehicleRouteType_edges', pyxb.binding.datatypes.string, required=True)
__edges._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 492, 8)
__edges._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 492, 8)
edges = property(__edges.value, __edges.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_vehicleRouteType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 493, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 493, 8)
color = property(__color.value, __color.set, None, None)
# Attribute exitTimes uses Python identifier exitTimes
__exitTimes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'exitTimes'), 'exitTimes', '__AbsentNamespace0_vehicleRouteType_exitTimes', pyxb.binding.datatypes.string)
__exitTimes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 494, 8)
__exitTimes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 494, 8)
exitTimes = property(__exitTimes.value, __exitTimes.set, None, None)
_ElementMap.update({
__stop.name() : __stop,
__param.name() : __param
})
_AttributeMap.update({
__edges.name() : __edges,
__color.name() : __color,
__exitTimes.name() : __exitTimes
})
_module_typeBindings.vehicleRouteType = vehicleRouteType
Namespace.addCategoryObject('typeBinding', 'vehicleRouteType', vehicleRouteType)
# Complex type routeDistRouteType with content type ELEMENT_ONLY
class routeDistRouteType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type routeDistRouteType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'routeDistRouteType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 497, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_routeDistRouteType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 499, 12), )
stop = property(__stop.value, __stop.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_routeDistRouteType_id', pyxb.binding.datatypes.string)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 501, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 501, 8)
id = property(__id.value, __id.set, None, None)
# Attribute edges uses Python identifier edges
__edges = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edges'), 'edges', '__AbsentNamespace0_routeDistRouteType_edges', pyxb.binding.datatypes.string)
__edges._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 502, 8)
__edges._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 502, 8)
edges = property(__edges.value, __edges.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_routeDistRouteType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 503, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 503, 8)
color = property(__color.value, __color.set, None, None)
# Attribute cost uses Python identifier cost
__cost = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'cost'), 'cost', '__AbsentNamespace0_routeDistRouteType_cost', pyxb.binding.datatypes.float)
__cost._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 504, 8)
__cost._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 504, 8)
cost = property(__cost.value, __cost.set, None, None)
# Attribute probability uses Python identifier probability
__probability = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'probability'), 'probability', '__AbsentNamespace0_routeDistRouteType_probability', pyxb.binding.datatypes.float)
__probability._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 505, 8)
__probability._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 505, 8)
probability = property(__probability.value, __probability.set, None, None)
# Attribute exitTimes uses Python identifier exitTimes
__exitTimes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'exitTimes'), 'exitTimes', '__AbsentNamespace0_routeDistRouteType_exitTimes', pyxb.binding.datatypes.string)
__exitTimes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 506, 8)
__exitTimes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 506, 8)
exitTimes = property(__exitTimes.value, __exitTimes.set, None, None)
# Attribute refId uses Python identifier refId
__refId = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'refId'), 'refId', '__AbsentNamespace0_routeDistRouteType_refId', pyxb.binding.datatypes.string)
__refId._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 507, 8)
__refId._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 507, 8)
refId = property(__refId.value, __refId.set, None, None)
# Attribute replacedOnEdge uses Python identifier replacedOnEdge
__replacedOnEdge = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'replacedOnEdge'), 'replacedOnEdge', '__AbsentNamespace0_routeDistRouteType_replacedOnEdge', pyxb.binding.datatypes.string)
__replacedOnEdge._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 508, 8)
__replacedOnEdge._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 508, 8)
replacedOnEdge = property(__replacedOnEdge.value, __replacedOnEdge.set, None, None)
# Attribute replacedAtTime uses Python identifier replacedAtTime
__replacedAtTime = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'replacedAtTime'), 'replacedAtTime', '__AbsentNamespace0_routeDistRouteType_replacedAtTime', _module_typeBindings.nonNegativeFloatType)
__replacedAtTime._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 509, 8)
__replacedAtTime._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 509, 8)
replacedAtTime = property(__replacedAtTime.value, __replacedAtTime.set, None, None)
_ElementMap.update({
__stop.name() : __stop
})
_AttributeMap.update({
__id.name() : __id,
__edges.name() : __edges,
__color.name() : __color,
__cost.name() : __cost,
__probability.name() : __probability,
__exitTimes.name() : __exitTimes,
__refId.name() : __refId,
__replacedOnEdge.name() : __replacedOnEdge,
__replacedAtTime.name() : __replacedAtTime
})
_module_typeBindings.routeDistRouteType = routeDistRouteType
Namespace.addCategoryObject('typeBinding', 'routeDistRouteType', routeDistRouteType)
# Complex type personType with content type ELEMENT_ONLY
class personType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type personType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'personType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 557, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element personTrip uses Python identifier personTrip
__personTrip = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'personTrip'), 'personTrip', '__AbsentNamespace0_personType_personTrip', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 559, 12), )
personTrip = property(__personTrip.value, __personTrip.set, None, None)
# Element ride uses Python identifier ride
__ride = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'ride'), 'ride', '__AbsentNamespace0_personType_ride', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 570, 12), )
ride = property(__ride.value, __ride.set, None, None)
# Element walk uses Python identifier walk
__walk = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'walk'), 'walk', '__AbsentNamespace0_personType_walk', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 580, 12), )
walk = property(__walk.value, __walk.set, None, None)
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_personType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 595, 12), )
stop = property(__stop.value, __stop.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_personType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 596, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_personType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 598, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 598, 8)
id = property(__id.value, __id.set, None, None)
# Attribute depart uses Python identifier depart
__depart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'depart'), 'depart', '__AbsentNamespace0_personType_depart', pyxb.binding.datatypes.float, required=True)
__depart._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 599, 8)
__depart._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 599, 8)
depart = property(__depart.value, __depart.set, None, None)
# Attribute arrival uses Python identifier arrival
__arrival = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrival'), 'arrival', '__AbsentNamespace0_personType_arrival', _module_typeBindings.nonNegativeFloatType)
__arrival._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 600, 8)
__arrival._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 600, 8)
arrival = property(__arrival.value, __arrival.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_personType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 601, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 601, 8)
type = property(__type.value, __type.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_personType_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 602, 8)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 602, 8)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_personType_arrivalPos', _module_typeBindings.arrivalPosType)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 603, 8)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 603, 8)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_personType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 604, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 604, 8)
color = property(__color.value, __color.set, None, None)
# Attribute modes uses Python identifier modes
__modes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'modes'), 'modes', '__AbsentNamespace0_personType_modes', pyxb.binding.datatypes.string)
__modes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 605, 8)
__modes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 605, 8)
modes = property(__modes.value, __modes.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_personType_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 606, 8)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 606, 8)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
_ElementMap.update({
__personTrip.name() : __personTrip,
__ride.name() : __ride,
__walk.name() : __walk,
__stop.name() : __stop,
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__depart.name() : __depart,
__arrival.name() : __arrival,
__type.name() : __type,
__departPos.name() : __departPos,
__arrivalPos.name() : __arrivalPos,
__color.name() : __color,
__modes.name() : __modes,
__vTypes.name() : __vTypes
})
_module_typeBindings.personType = personType
Namespace.addCategoryObject('typeBinding', 'personType', personType)
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_13 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 560, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_CTD_ANON_13_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 561, 20)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 561, 20)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_CTD_ANON_13_to', pyxb.binding.datatypes.string, required=True)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 562, 20)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 562, 20)
to = property(__to.value, __to.set, None, None)
# Attribute modes uses Python identifier modes
__modes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'modes'), 'modes', '__AbsentNamespace0_CTD_ANON_13_modes', pyxb.binding.datatypes.string)
__modes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 563, 20)
__modes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 563, 20)
modes = property(__modes.value, __modes.set, None, None)
# Attribute vTypes uses Python identifier vTypes
__vTypes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'vTypes'), 'vTypes', '__AbsentNamespace0_CTD_ANON_13_vTypes', pyxb.binding.datatypes.string)
__vTypes._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 564, 20)
__vTypes._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 564, 20)
vTypes = property(__vTypes.value, __vTypes.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_CTD_ANON_13_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 565, 20)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 565, 20)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_CTD_ANON_13_arrivalPos', _module_typeBindings.arrivalPosType)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 566, 20)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 566, 20)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute walkFactor uses Python identifier walkFactor
__walkFactor = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'walkFactor'), 'walkFactor', '__AbsentNamespace0_CTD_ANON_13_walkFactor', _module_typeBindings.positiveFloatType)
__walkFactor._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 567, 20)
__walkFactor._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 567, 20)
walkFactor = property(__walkFactor.value, __walkFactor.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__from.name() : __from,
__to.name() : __to,
__modes.name() : __modes,
__vTypes.name() : __vTypes,
__departPos.name() : __departPos,
__arrivalPos.name() : __arrivalPos,
__walkFactor.name() : __walkFactor
})
_module_typeBindings.CTD_ANON_13 = CTD_ANON_13
# Complex type [anonymous] with content type EMPTY
class CTD_ANON_14 (pyxb.binding.basis.complexTypeDefinition):
"""Complex type [anonymous] with content type EMPTY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
_Abstract = False
_ExpandedName = None
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 581, 16)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Attribute route uses Python identifier route
__route = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'route'), 'route', '__AbsentNamespace0_CTD_ANON_14_route', pyxb.binding.datatypes.string)
__route._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 582, 20)
__route._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 582, 20)
route = property(__route.value, __route.set, None, None)
# Attribute edges uses Python identifier edges
__edges = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'edges'), 'edges', '__AbsentNamespace0_CTD_ANON_14_edges', pyxb.binding.datatypes.string)
__edges._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 583, 20)
__edges._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 583, 20)
edges = property(__edges.value, __edges.set, None, None)
# Attribute from uses Python identifier from_
__from = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'from'), 'from_', '__AbsentNamespace0_CTD_ANON_14_from', pyxb.binding.datatypes.string)
__from._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 584, 20)
__from._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 584, 20)
from_ = property(__from.value, __from.set, None, None)
# Attribute to uses Python identifier to
__to = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'to'), 'to', '__AbsentNamespace0_CTD_ANON_14_to', pyxb.binding.datatypes.string)
__to._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 585, 20)
__to._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 585, 20)
to = property(__to.value, __to.set, None, None)
# Attribute busStop uses Python identifier busStop
__busStop = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'busStop'), 'busStop', '__AbsentNamespace0_CTD_ANON_14_busStop', pyxb.binding.datatypes.string)
__busStop._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 586, 20)
__busStop._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 586, 20)
busStop = property(__busStop.value, __busStop.set, None, None)
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_CTD_ANON_14_speed', _module_typeBindings.positiveFloatType)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 587, 20)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 587, 20)
speed = property(__speed.value, __speed.set, None, None)
# Attribute duration uses Python identifier duration
__duration = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'duration'), 'duration', '__AbsentNamespace0_CTD_ANON_14_duration', _module_typeBindings.positiveFloatType)
__duration._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 588, 20)
__duration._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 588, 20)
duration = property(__duration.value, __duration.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_CTD_ANON_14_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 589, 20)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 589, 20)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute departPosLat uses Python identifier departPosLat
__departPosLat = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPosLat'), 'departPosLat', '__AbsentNamespace0_CTD_ANON_14_departPosLat', pyxb.binding.datatypes.float)
__departPosLat._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 590, 20)
__departPosLat._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 590, 20)
departPosLat = property(__departPosLat.value, __departPosLat.set, None, None)
# Attribute arrivalPos uses Python identifier arrivalPos
__arrivalPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrivalPos'), 'arrivalPos', '__AbsentNamespace0_CTD_ANON_14_arrivalPos', _module_typeBindings.arrivalPosType)
__arrivalPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 591, 20)
__arrivalPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 591, 20)
arrivalPos = property(__arrivalPos.value, __arrivalPos.set, None, None)
# Attribute cost uses Python identifier cost
__cost = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'cost'), 'cost', '__AbsentNamespace0_CTD_ANON_14_cost', pyxb.binding.datatypes.float)
__cost._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 592, 20)
__cost._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 592, 20)
cost = property(__cost.value, __cost.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__route.name() : __route,
__edges.name() : __edges,
__from.name() : __from,
__to.name() : __to,
__busStop.name() : __busStop,
__speed.name() : __speed,
__duration.name() : __duration,
__departPos.name() : __departPos,
__departPosLat.name() : __departPosLat,
__arrivalPos.name() : __arrivalPos,
__cost.name() : __cost
})
_module_typeBindings.CTD_ANON_14 = CTD_ANON_14
# Complex type containerType with content type ELEMENT_ONLY
class containerType (pyxb.binding.basis.complexTypeDefinition):
"""Complex type containerType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'containerType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 609, 4)
_ElementMap = {}
_AttributeMap = {}
# Base type is pyxb.binding.datatypes.anyType
# Element transport uses Python identifier transport
__transport = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'transport'), 'transport', '__AbsentNamespace0_containerType_transport', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 611, 12), )
transport = property(__transport.value, __transport.set, None, None)
# Element tranship uses Python identifier tranship
__tranship = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'tranship'), 'tranship', '__AbsentNamespace0_containerType_tranship', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 618, 12), )
tranship = property(__tranship.value, __tranship.set, None, None)
# Element stop uses Python identifier stop
__stop = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'stop'), 'stop', '__AbsentNamespace0_containerType_stop', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 629, 12), )
stop = property(__stop.value, __stop.set, None, None)
# Element param uses Python identifier param
__param = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(None, 'param'), 'param', '__AbsentNamespace0_containerType_param', True, pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 630, 12), )
param = property(__param.value, __param.set, None, None)
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_containerType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 632, 8)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 632, 8)
id = property(__id.value, __id.set, None, None)
# Attribute depart uses Python identifier depart
__depart = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'depart'), 'depart', '__AbsentNamespace0_containerType_depart', pyxb.binding.datatypes.float, required=True)
__depart._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 633, 8)
__depart._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 633, 8)
depart = property(__depart.value, __depart.set, None, None)
# Attribute arrival uses Python identifier arrival
__arrival = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'arrival'), 'arrival', '__AbsentNamespace0_containerType_arrival', _module_typeBindings.nonNegativeFloatType)
__arrival._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 634, 8)
__arrival._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 634, 8)
arrival = property(__arrival.value, __arrival.set, None, None)
# Attribute type uses Python identifier type
__type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__AbsentNamespace0_containerType_type', pyxb.binding.datatypes.string)
__type._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 635, 8)
__type._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 635, 8)
type = property(__type.value, __type.set, None, None)
# Attribute departPos uses Python identifier departPos
__departPos = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'departPos'), 'departPos', '__AbsentNamespace0_containerType_departPos', _module_typeBindings.departPosType)
__departPos._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 636, 8)
__departPos._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 636, 8)
departPos = property(__departPos.value, __departPos.set, None, None)
# Attribute color uses Python identifier color
__color = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'color'), 'color', '__AbsentNamespace0_containerType_color', _module_typeBindings.colorType)
__color._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 637, 8)
__color._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 637, 8)
color = property(__color.value, __color.set, None, None)
_ElementMap.update({
__transport.name() : __transport,
__tranship.name() : __tranship,
__stop.name() : __stop,
__param.name() : __param
})
_AttributeMap.update({
__id.name() : __id,
__depart.name() : __depart,
__arrival.name() : __arrival,
__type.name() : __type,
__departPos.name() : __departPos,
__color.name() : __color
})
_module_typeBindings.containerType = containerType
Namespace.addCategoryObject('typeBinding', 'containerType', containerType)
# Complex type flowCalibratorType with content type ELEMENT_ONLY
class flowCalibratorType (flowWithoutIDType):
"""Complex type flowCalibratorType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'flowCalibratorType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 331, 4)
_ElementMap = flowWithoutIDType._ElementMap.copy()
_AttributeMap = flowWithoutIDType._AttributeMap.copy()
# Base type is flowWithoutIDType
# Element route (route) inherited from flowWithoutIDType
# Element routeDistribution (routeDistribution) inherited from flowWithoutIDType
# Element stop (stop) inherited from flowWithoutIDType
# Element param (param) inherited from flowWithoutIDType
# Attribute route_ inherited from flowWithoutIDType
# Attribute fromTaz inherited from flowWithoutIDType
# Attribute toTaz inherited from flowWithoutIDType
# Attribute from_ inherited from flowWithoutIDType
# Attribute to inherited from flowWithoutIDType
# Attribute via inherited from flowWithoutIDType
# Attribute type inherited from flowWithoutIDType
# Attribute begin inherited from flowWithoutIDType
# Attribute end inherited from flowWithoutIDType
# Attribute period inherited from flowWithoutIDType
# Attribute vehsPerHour inherited from flowWithoutIDType
# Attribute probability inherited from flowWithoutIDType
# Attribute number inherited from flowWithoutIDType
# Attribute color inherited from flowWithoutIDType
# Attribute departLane inherited from flowWithoutIDType
# Attribute departPos inherited from flowWithoutIDType
# Attribute departSpeed inherited from flowWithoutIDType
# Attribute arrivalLane inherited from flowWithoutIDType
# Attribute arrivalPos inherited from flowWithoutIDType
# Attribute arrivalSpeed inherited from flowWithoutIDType
# Attribute departPosLat inherited from flowWithoutIDType
# Attribute arrivalPosLat inherited from flowWithoutIDType
# Attribute line inherited from flowWithoutIDType
# Attribute personNumber inherited from flowWithoutIDType
# Attribute speed uses Python identifier speed
__speed = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'speed'), 'speed', '__AbsentNamespace0_flowCalibratorType_speed', _module_typeBindings.nonNegativeFloatType)
__speed._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 334, 16)
__speed._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 334, 16)
speed = property(__speed.value, __speed.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__speed.name() : __speed
})
_module_typeBindings.flowCalibratorType = flowCalibratorType
Namespace.addCategoryObject('typeBinding', 'flowCalibratorType', flowCalibratorType)
# Complex type flowType with content type ELEMENT_ONLY
class flowType (flowWithoutIDType):
"""Complex type flowType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'flowType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 339, 4)
_ElementMap = flowWithoutIDType._ElementMap.copy()
_AttributeMap = flowWithoutIDType._AttributeMap.copy()
# Base type is flowWithoutIDType
# Element route (route) inherited from flowWithoutIDType
# Element routeDistribution (routeDistribution) inherited from flowWithoutIDType
# Element stop (stop) inherited from flowWithoutIDType
# Element param (param) inherited from flowWithoutIDType
# Attribute route_ inherited from flowWithoutIDType
# Attribute fromTaz inherited from flowWithoutIDType
# Attribute toTaz inherited from flowWithoutIDType
# Attribute from_ inherited from flowWithoutIDType
# Attribute to inherited from flowWithoutIDType
# Attribute via inherited from flowWithoutIDType
# Attribute type inherited from flowWithoutIDType
# Attribute begin inherited from flowWithoutIDType
# Attribute end inherited from flowWithoutIDType
# Attribute period inherited from flowWithoutIDType
# Attribute vehsPerHour inherited from flowWithoutIDType
# Attribute probability inherited from flowWithoutIDType
# Attribute number inherited from flowWithoutIDType
# Attribute color inherited from flowWithoutIDType
# Attribute departLane inherited from flowWithoutIDType
# Attribute departPos inherited from flowWithoutIDType
# Attribute departSpeed inherited from flowWithoutIDType
# Attribute arrivalLane inherited from flowWithoutIDType
# Attribute arrivalPos inherited from flowWithoutIDType
# Attribute arrivalSpeed inherited from flowWithoutIDType
# Attribute departPosLat inherited from flowWithoutIDType
# Attribute arrivalPosLat inherited from flowWithoutIDType
# Attribute line inherited from flowWithoutIDType
# Attribute personNumber inherited from flowWithoutIDType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_flowType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 342, 16)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 342, 16)
id = property(__id.value, __id.set, None, None)
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id
})
_module_typeBindings.flowType = flowType
Namespace.addCategoryObject('typeBinding', 'flowType', flowType)
# Complex type routeType with content type ELEMENT_ONLY
class routeType (vehicleRouteType):
"""Complex type routeType with content type ELEMENT_ONLY"""
_TypeDefinition = None
_ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
_Abstract = False
_ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'routeType')
_XSDLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 371, 4)
_ElementMap = vehicleRouteType._ElementMap.copy()
_AttributeMap = vehicleRouteType._AttributeMap.copy()
# Base type is vehicleRouteType
# Element stop (stop) inherited from vehicleRouteType
# Element param (param) inherited from vehicleRouteType
# Attribute id uses Python identifier id
__id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__AbsentNamespace0_routeType_id', pyxb.binding.datatypes.string, required=True)
__id._DeclarationLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 374, 16)
__id._UseLocation = pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 374, 16)
id = property(__id.value, __id.set, None, None)
# Attribute edges inherited from vehicleRouteType
# Attribute color inherited from vehicleRouteType
# Attribute exitTimes inherited from vehicleRouteType
_ElementMap.update({
})
_AttributeMap.update({
__id.name() : __id
})
_module_typeBindings.routeType = routeType
Namespace.addCategoryObject('typeBinding', 'routeType', routeType)
additional = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'additional'), additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 7, 4))
Namespace.addCategoryObject('elementBinding', additional.name().localName(), additional)
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'location'), locationType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 11, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'vTypeProbe'), vTypeProbeType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 12, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'e1Detector'), e1DetectorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 13, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'inductionLoop'), e1DetectorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 14, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'e2Detector'), e2DetectorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 15, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'laneAreaDetector'), e2DetectorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 16, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'e3Detector'), e3DetectorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 17, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'entryExitDetector'), e3DetectorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 18, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'edgeData'), meandataType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 19, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'laneData'), meandataType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 20, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'timedEvent'), timedEventType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 21, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'tlLogic'), tlLogicAdditionalType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 22, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'WAUT'), WAUTType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 23, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'wautJunction'), wautJunctionType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 24, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'variableSpeedSign'), variableSpeedSignType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 25, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'routeProbe'), routeProbeType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 26, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'rerouter'), rerouterType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 27, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'instantInductionLoop'), instantInductionLoopType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 28, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'busStop'), stoppingPlaceType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 29, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'trainStop'), stoppingPlaceType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 30, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'containerStop'), stoppingPlaceType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 31, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'chargingStation'), chargingStationType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 32, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'parkingArea'), parkingAreaType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 33, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'calibrator'), calibratorType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 34, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'vaporizer'), vaporizerType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 35, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'vTypeDistribution'), vTypeDistributionType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 37, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'routeDistribution'), routeDistributionType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 38, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'vType'), vTypeType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 39, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'route'), routeType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 40, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'vehicle'), vehicleType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 41, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'flow'), flowType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 42, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'person'), personType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 43, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'interval'), intervalType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 45, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'poly'), polygonType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 47, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'poi'), poiType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 48, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'type'), typeType, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 50, 12)))
additionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'include'), CTD_ANON, scope=additionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 52, 12)))
def _BuildAutomaton ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton
del _BuildAutomaton
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 11, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 12, 12))
counters.add(cc_1)
cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 13, 12))
counters.add(cc_2)
cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 14, 12))
counters.add(cc_3)
cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 15, 12))
counters.add(cc_4)
cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 16, 12))
counters.add(cc_5)
cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 17, 12))
counters.add(cc_6)
cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 18, 12))
counters.add(cc_7)
cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 19, 12))
counters.add(cc_8)
cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 20, 12))
counters.add(cc_9)
cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 21, 12))
counters.add(cc_10)
cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 22, 12))
counters.add(cc_11)
cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 23, 12))
counters.add(cc_12)
cc_13 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 24, 12))
counters.add(cc_13)
cc_14 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 25, 12))
counters.add(cc_14)
cc_15 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 26, 12))
counters.add(cc_15)
cc_16 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 27, 12))
counters.add(cc_16)
cc_17 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 28, 12))
counters.add(cc_17)
cc_18 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 29, 12))
counters.add(cc_18)
cc_19 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 30, 12))
counters.add(cc_19)
cc_20 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 31, 12))
counters.add(cc_20)
cc_21 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 32, 12))
counters.add(cc_21)
cc_22 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 33, 12))
counters.add(cc_22)
cc_23 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 34, 12))
counters.add(cc_23)
cc_24 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 35, 12))
counters.add(cc_24)
cc_25 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 37, 12))
counters.add(cc_25)
cc_26 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 38, 12))
counters.add(cc_26)
cc_27 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 39, 12))
counters.add(cc_27)
cc_28 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 40, 12))
counters.add(cc_28)
cc_29 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 41, 12))
counters.add(cc_29)
cc_30 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 42, 12))
counters.add(cc_30)
cc_31 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 43, 12))
counters.add(cc_31)
cc_32 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 45, 12))
counters.add(cc_32)
cc_33 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 47, 12))
counters.add(cc_33)
cc_34 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 48, 12))
counters.add(cc_34)
cc_35 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 50, 12))
counters.add(cc_35)
cc_36 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 52, 12))
counters.add(cc_36)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'location')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 11, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'vTypeProbe')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 12, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_2, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'e1Detector')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 13, 12))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_3, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'inductionLoop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 14, 12))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_4, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'e2Detector')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 15, 12))
st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_4)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_5, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'laneAreaDetector')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 16, 12))
st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_5)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_6, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'e3Detector')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 17, 12))
st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_6)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_7, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'entryExitDetector')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 18, 12))
st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_7)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_8, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'edgeData')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 19, 12))
st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_8)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_9, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'laneData')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 20, 12))
st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_9)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_10, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'timedEvent')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 21, 12))
st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_10)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_11, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'tlLogic')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 22, 12))
st_11 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_11)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_12, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'WAUT')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 23, 12))
st_12 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_12)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_13, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'wautJunction')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 24, 12))
st_13 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_13)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_14, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'variableSpeedSign')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 25, 12))
st_14 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_14)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_15, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'routeProbe')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 26, 12))
st_15 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_15)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_16, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'rerouter')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 27, 12))
st_16 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_16)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_17, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'instantInductionLoop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 28, 12))
st_17 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_17)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_18, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'busStop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 29, 12))
st_18 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_18)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_19, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'trainStop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 30, 12))
st_19 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_19)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_20, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'containerStop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 31, 12))
st_20 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_20)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_21, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'chargingStation')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 32, 12))
st_21 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_21)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_22, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'parkingArea')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 33, 12))
st_22 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_22)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_23, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'calibrator')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 34, 12))
st_23 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_23)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_24, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'vaporizer')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 35, 12))
st_24 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_24)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_25, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'vTypeDistribution')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 37, 12))
st_25 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_25)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_26, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'routeDistribution')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 38, 12))
st_26 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_26)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_27, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'vType')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 39, 12))
st_27 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_27)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_28, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 40, 12))
st_28 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_28)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_29, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'vehicle')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 41, 12))
st_29 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_29)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_30, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'flow')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 42, 12))
st_30 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_30)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_31, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'person')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 43, 12))
st_31 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_31)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_32, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'interval')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 45, 12))
st_32 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_32)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_33, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'poly')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 47, 12))
st_33 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_33)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_34, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'poi')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 48, 12))
st_34 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_34)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_35, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'type')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 50, 12))
st_35 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_35)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_36, False))
symbol = pyxb.binding.content.ElementUse(additionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'include')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 52, 12))
st_36 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_36)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_1, False) ]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_2, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_2, False) ]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_3, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_3, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_3, False) ]))
st_3._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_4, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_4, False) ]))
st_4._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_5, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_5, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_5, False) ]))
st_5._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_6, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_6, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_6, False) ]))
st_6._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_7, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_7, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_7, False) ]))
st_7._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_8, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_8, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_8, False) ]))
st_8._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_9, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_9, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_9, False) ]))
st_9._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_10, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_10, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_10, False) ]))
st_10._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_11, True) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_11, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_11, False) ]))
st_11._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_12, True) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_12, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_12, False) ]))
st_12._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_13, True) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_13, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_13, False) ]))
st_13._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_14, True) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_14, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_14, False) ]))
st_14._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_15, True) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_15, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_15, False) ]))
st_15._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_16, True) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_16, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_16, False) ]))
st_16._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_17, True) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_17, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_17, False) ]))
st_17._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_18, True) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_18, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_18, False) ]))
st_18._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_19, True) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_19, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_19, False) ]))
st_19._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_20, True) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_20, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_20, False) ]))
st_20._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_21, True) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_21, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_21, False) ]))
st_21._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_22, True) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_22, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_22, False) ]))
st_22._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_23, True) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_23, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_23, False) ]))
st_23._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_24, True) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_24, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_24, False) ]))
st_24._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_25, True) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_25, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_25, False) ]))
st_25._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_26, True) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_26, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_26, False) ]))
st_26._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_27, True) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_27, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_27, False) ]))
st_27._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_28, True) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_28, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_28, False) ]))
st_28._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_29, True) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_29, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_29, False) ]))
st_29._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_30, True) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_30, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_30, False) ]))
st_30._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_31, True) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_31, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_31, False) ]))
st_31._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_32, True) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_32, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_32, False) ]))
st_32._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_33, True) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_33, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_33, False) ]))
st_33._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_34, True) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_34, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_34, False) ]))
st_34._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_35, True) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_35, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_35, False) ]))
st_35._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_12, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_13, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_14, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_15, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_16, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_17, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_18, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_19, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_20, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_21, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_22, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_23, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_24, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_25, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_26, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_27, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_28, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_29, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_30, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_31, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_32, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_33, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_34, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_35, [
fac.UpdateInstruction(cc_36, False) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_36, True) ]))
transitions.append(fac.Transition(st_36, [
fac.UpdateInstruction(cc_36, False) ]))
st_36._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
additionalType._Automaton = _BuildAutomaton()
WAUTType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'wautSwitch'), wautSwitchType, scope=WAUTType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 167, 12)))
def _BuildAutomaton_ ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_
del _BuildAutomaton_
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 167, 12))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(WAUTType._UseForTag(pyxb.namespace.ExpandedName(None, 'wautSwitch')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 167, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
WAUTType._Automaton = _BuildAutomaton_()
variableSpeedSignType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'step'), CTD_ANON_6, scope=variableSpeedSignType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 188, 12)))
def _BuildAutomaton_2 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_2
del _BuildAutomaton_2
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 187, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(variableSpeedSignType._UseForTag(pyxb.namespace.ExpandedName(None, 'step')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 188, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
variableSpeedSignType._Automaton = _BuildAutomaton_2()
vTypeDistributionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'vType'), vTypeType, scope=vTypeDistributionType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 533, 12)))
def _BuildAutomaton_3 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_3
del _BuildAutomaton_3
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 532, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(vTypeDistributionType._UseForTag(pyxb.namespace.ExpandedName(None, 'vType')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 533, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
vTypeDistributionType._Automaton = _BuildAutomaton_3()
routeDistributionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'route'), routeDistRouteType, scope=routeDistributionType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 541, 12)))
def _BuildAutomaton_4 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_4
del _BuildAutomaton_4
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 540, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(routeDistributionType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 541, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
routeDistributionType._Automaton = _BuildAutomaton_4()
vehicleRouteDistributionType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'route'), routeDistRouteType, scope=vehicleRouteDistributionType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 551, 12)))
def _BuildAutomaton_5 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_5
del _BuildAutomaton_5
import pyxb.utils.fac as fac
counters = set()
states = []
final_update = set()
symbol = pyxb.binding.content.ElementUse(vehicleRouteDistributionType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 551, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, False, containing_state=None)
vehicleRouteDistributionType._Automaton = _BuildAutomaton_5()
e3DetectorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'detEntry'), detEntryExitType, scope=e3DetectorType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 98, 12)))
e3DetectorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'detExit'), detEntryExitType, scope=e3DetectorType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 100, 12)))
def _BuildAutomaton_6 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_6
del _BuildAutomaton_6
import pyxb.utils.fac as fac
counters = set()
states = []
final_update = None
symbol = pyxb.binding.content.ElementUse(e3DetectorType._UseForTag(pyxb.namespace.ExpandedName(None, 'detEntry')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 98, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
symbol = pyxb.binding.content.ElementUse(e3DetectorType._UseForTag(pyxb.namespace.ExpandedName(None, 'detExit')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 100, 12))
st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, False, containing_state=None)
e3DetectorType._Automaton = _BuildAutomaton_6()
rerouterType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'interval'), CTD_ANON_7, scope=rerouterType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 211, 12)))
def _BuildAutomaton_7 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_7
del _BuildAutomaton_7
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 210, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(rerouterType._UseForTag(pyxb.namespace.ExpandedName(None, 'interval')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 211, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
rerouterType._Automaton = _BuildAutomaton_7()
CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'closingReroute'), CTD_ANON_, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 214, 24)))
CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'closingLaneReroute'), CTD_ANON_2, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 221, 24)))
CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'destProbReroute'), CTD_ANON_8, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 228, 24)))
CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'routeProbReroute'), CTD_ANON_9, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 234, 24)))
CTD_ANON_7._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'parkingAreaReroute'), CTD_ANON_10, scope=CTD_ANON_7, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 240, 24)))
def _BuildAutomaton_8 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_8
del _BuildAutomaton_8
import pyxb.utils.fac as fac
counters = set()
states = []
final_update = set()
symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(None, 'closingReroute')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 214, 24))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(None, 'closingLaneReroute')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 221, 24))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(None, 'destProbReroute')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 228, 24))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(None, 'routeProbReroute')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 234, 24))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
final_update = set()
symbol = pyxb.binding.content.ElementUse(CTD_ANON_7._UseForTag(pyxb.namespace.ExpandedName(None, 'parkingAreaReroute')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 240, 24))
st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_4)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_3._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_4._set_transitionSet(transitions)
return fac.Automaton(states, counters, False, containing_state=None)
CTD_ANON_7._Automaton = _BuildAutomaton_8()
stoppingPlaceType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'access'), CTD_ANON_3, scope=stoppingPlaceType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 268, 12)))
def _BuildAutomaton_9 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_9
del _BuildAutomaton_9
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 267, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(stoppingPlaceType._UseForTag(pyxb.namespace.ExpandedName(None, 'access')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 268, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
stoppingPlaceType._Automaton = _BuildAutomaton_9()
parkingAreaType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'space'), parkingSpaceType, scope=parkingAreaType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 302, 12)))
def _BuildAutomaton_10 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_10
del _BuildAutomaton_10
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 302, 12))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(parkingAreaType._UseForTag(pyxb.namespace.ExpandedName(None, 'space')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 302, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
parkingAreaType._Automaton = _BuildAutomaton_10()
calibratorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'route'), routeType, scope=calibratorType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 327, 12)))
calibratorType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'flow'), flowCalibratorType, scope=calibratorType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 328, 12)))
def _BuildAutomaton_11 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_11
del _BuildAutomaton_11
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 327, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 328, 12))
counters.add(cc_1)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(calibratorType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 327, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(calibratorType._UseForTag(pyxb.namespace.ExpandedName(None, 'flow')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 328, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_1, False) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, False) ]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
calibratorType._Automaton = _BuildAutomaton_11()
tlLogicAdditionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'phase'), phaseType, scope=tlLogicAdditionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 385, 12)))
tlLogicAdditionalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=tlLogicAdditionalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 386, 12)))
def _BuildAutomaton_12 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_12
del _BuildAutomaton_12
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 384, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(tlLogicAdditionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'phase')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 385, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(tlLogicAdditionalType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 386, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
tlLogicAdditionalType._Automaton = _BuildAutomaton_12()
tlLogicType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'phase'), phaseType, scope=tlLogicType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 199, 12)))
tlLogicType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=tlLogicType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 200, 12)))
def _BuildAutomaton_13 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_13
del _BuildAutomaton_13
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 198, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(tlLogicType._UseForTag(pyxb.namespace.ExpandedName(None, 'phase')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 199, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(tlLogicType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 200, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
tlLogicType._Automaton = _BuildAutomaton_13()
typeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'restriction'), restrictionType, scope=typeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 237, 12)))
def _BuildAutomaton_14 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_14
del _BuildAutomaton_14
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 236, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(typeType._UseForTag(pyxb.namespace.ExpandedName(None, 'restriction')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/baseTypes.xsd', 237, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
typeType._Automaton = _BuildAutomaton_14()
intervalType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'edge'), CTD_ANON_12, scope=intervalType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 8, 12)))
def _BuildAutomaton_15 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_15
del _BuildAutomaton_15
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 8, 12))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(intervalType._UseForTag(pyxb.namespace.ExpandedName(None, 'edge')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 8, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
intervalType._Automaton = _BuildAutomaton_15()
polygonType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=polygonType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 348, 12)))
def _BuildAutomaton_16 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_16
del _BuildAutomaton_16
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 348, 12))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(polygonType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 348, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
polygonType._Automaton = _BuildAutomaton_16()
poiType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=poiType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 363, 12)))
def _BuildAutomaton_17 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_17
del _BuildAutomaton_17
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 363, 12))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(poiType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/additional_file.xsd', 363, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
poiType._Automaton = _BuildAutomaton_17()
CTD_ANON_12._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'lane'), edgeLaneDataType, scope=CTD_ANON_12, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 13, 32)))
def _BuildAutomaton_18 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_18
del _BuildAutomaton_18
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 13, 32))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(CTD_ANON_12._UseForTag(pyxb.namespace.ExpandedName(None, 'lane')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/meandataTypes.xsd', 13, 32))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
CTD_ANON_12._Automaton = _BuildAutomaton_18()
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 8, 12)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-IDM'), cfIDMType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 11, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-IDMM'), cfIDMMType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 12, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-Krauss'), cfKraussType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 13, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-KraussPS'), cfKraussType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 14, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-KraussOrig1'), cfKraussType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 15, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-SmartSK'), cfSmartType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 16, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-Daniel1'), cfSmartType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 17, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-PWagner2009'), cfPWagType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 18, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-BKerner'), cfBKernerType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 19, 20)))
vTypeType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'carFollowing-Wiedemann'), cfWiedemannType, scope=vTypeType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 20, 20)))
def _BuildAutomaton_19 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_19
del _BuildAutomaton_19
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 8, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 9, 12))
counters.add(cc_1)
cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 22, 16))
counters.add(cc_2)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 8, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-IDM')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 11, 20))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-IDMM')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 12, 20))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-Krauss')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 13, 20))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-KraussPS')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 14, 20))
st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_4)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-KraussOrig1')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 15, 20))
st_5 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_5)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-SmartSK')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 16, 20))
st_6 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_6)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-Daniel1')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 17, 20))
st_7 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_7)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-PWagner2009')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 18, 20))
st_8 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_8)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-BKerner')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 19, 20))
st_9 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_9)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'carFollowing-Wiedemann')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 20, 20))
st_10 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_10)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
final_update.add(fac.UpdateInstruction(cc_2, False))
symbol = pyxb.binding.content.ElementUse(vTypeType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 22, 16))
st_11 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
states.append(st_11)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_3._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_4._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_5._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_6._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_7._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_8._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_9._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_11, [
]))
st_10._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_6, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_7, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_8, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_9, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_10, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_11, [
fac.UpdateInstruction(cc_2, True) ]))
st_11._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
vTypeType._Automaton = _BuildAutomaton_19()
vehicleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=vehicleType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 260, 12)))
vehicleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'route'), vehicleRouteType, scope=vehicleType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 263, 20)))
vehicleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'routeDistribution'), vehicleRouteDistributionType, scope=vehicleType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 264, 20)))
vehicleType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=vehicleType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 269, 16)))
def _BuildAutomaton_20 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_20
del _BuildAutomaton_20
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 260, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 261, 12))
counters.add(cc_1)
cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 266, 16))
counters.add(cc_2)
cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 268, 12))
counters.add(cc_3)
cc_4 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 270, 16))
counters.add(cc_4)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(vehicleType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 260, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vehicleType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 263, 20))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(vehicleType._UseForTag(pyxb.namespace.ExpandedName(None, 'routeDistribution')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 264, 20))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
final_update.add(fac.UpdateInstruction(cc_2, False))
symbol = pyxb.binding.content.ElementUse(vehicleType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 266, 16))
st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_3, False))
symbol = pyxb.binding.content.ElementUse(vehicleType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 269, 16))
st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_4)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_3, False))
final_update.add(fac.UpdateInstruction(cc_4, False))
symbol = pyxb.binding.content.ElementUse(vehicleType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 270, 16))
st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False)
states.append(st_5)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, False) ]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, False) ]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True),
fac.UpdateInstruction(cc_2, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_2, True) ]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_1, False),
fac.UpdateInstruction(cc_2, False) ]))
st_3._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_4, [
]))
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_3, True) ]))
transitions.append(fac.Transition(st_5, [
]))
st_4._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_4, [
fac.UpdateInstruction(cc_3, True),
fac.UpdateInstruction(cc_4, False) ]))
transitions.append(fac.Transition(st_5, [
fac.UpdateInstruction(cc_4, True) ]))
st_5._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
vehicleType._Automaton = _BuildAutomaton_20()
flowWithoutIDType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'route'), vehicleRouteType, scope=flowWithoutIDType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 299, 16)))
flowWithoutIDType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'routeDistribution'), vehicleRouteDistributionType, scope=flowWithoutIDType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 300, 16)))
flowWithoutIDType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=flowWithoutIDType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12)))
flowWithoutIDType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=flowWithoutIDType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12)))
def _BuildAutomaton_21 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_21
del _BuildAutomaton_21
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 298, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12))
counters.add(cc_1)
cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12))
counters.add(cc_2)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(flowWithoutIDType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 299, 16))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(flowWithoutIDType._UseForTag(pyxb.namespace.ExpandedName(None, 'routeDistribution')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 300, 16))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(flowWithoutIDType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_2, False))
symbol = pyxb.binding.content.ElementUse(flowWithoutIDType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, False) ]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_2, True) ]))
st_3._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
flowWithoutIDType._Automaton = _BuildAutomaton_21()
tripType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=tripType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 349, 12)))
tripType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=tripType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 350, 12)))
def _BuildAutomaton_22 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_22
del _BuildAutomaton_22
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 349, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 350, 12))
counters.add(cc_1)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(tripType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 349, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(tripType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 350, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_1, True) ]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
tripType._Automaton = _BuildAutomaton_22()
vehicleRouteType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=vehicleRouteType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 489, 12)))
vehicleRouteType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=vehicleRouteType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 490, 12)))
def _BuildAutomaton_23 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_23
del _BuildAutomaton_23
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 488, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(vehicleRouteType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 489, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(vehicleRouteType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 490, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
vehicleRouteType._Automaton = _BuildAutomaton_23()
routeDistRouteType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=routeDistRouteType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 499, 12)))
def _BuildAutomaton_24 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_24
del _BuildAutomaton_24
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 499, 12))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(routeDistRouteType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 499, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
routeDistRouteType._Automaton = _BuildAutomaton_24()
personType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'personTrip'), CTD_ANON_13, scope=personType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 559, 12)))
personType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'ride'), CTD_ANON_4, scope=personType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 570, 12)))
personType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'walk'), CTD_ANON_14, scope=personType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 580, 12)))
personType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=personType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 595, 12)))
personType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=personType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 596, 12)))
def _BuildAutomaton_25 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_25
del _BuildAutomaton_25
import pyxb.utils.fac as fac
counters = set()
states = []
final_update = set()
symbol = pyxb.binding.content.ElementUse(personType._UseForTag(pyxb.namespace.ExpandedName(None, 'personTrip')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 559, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
symbol = pyxb.binding.content.ElementUse(personType._UseForTag(pyxb.namespace.ExpandedName(None, 'ride')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 570, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
symbol = pyxb.binding.content.ElementUse(personType._UseForTag(pyxb.namespace.ExpandedName(None, 'walk')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 580, 12))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
symbol = pyxb.binding.content.ElementUse(personType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 595, 12))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
final_update = set()
symbol = pyxb.binding.content.ElementUse(personType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 596, 12))
st_4 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_4)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_3._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
transitions.append(fac.Transition(st_4, [
]))
st_4._set_transitionSet(transitions)
return fac.Automaton(states, counters, False, containing_state=None)
personType._Automaton = _BuildAutomaton_25()
containerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'transport'), CTD_ANON_5, scope=containerType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 611, 12)))
containerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'tranship'), CTD_ANON_11, scope=containerType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 618, 12)))
containerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'stop'), stopType, scope=containerType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 629, 12)))
containerType._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(None, 'param'), paramType, scope=containerType, location=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 630, 12)))
def _BuildAutomaton_26 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_26
del _BuildAutomaton_26
import pyxb.utils.fac as fac
counters = set()
states = []
final_update = set()
symbol = pyxb.binding.content.ElementUse(containerType._UseForTag(pyxb.namespace.ExpandedName(None, 'transport')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 611, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
symbol = pyxb.binding.content.ElementUse(containerType._UseForTag(pyxb.namespace.ExpandedName(None, 'tranship')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 618, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
symbol = pyxb.binding.content.ElementUse(containerType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 629, 12))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
symbol = pyxb.binding.content.ElementUse(containerType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 630, 12))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
]))
transitions.append(fac.Transition(st_1, [
]))
transitions.append(fac.Transition(st_2, [
]))
transitions.append(fac.Transition(st_3, [
]))
st_3._set_transitionSet(transitions)
return fac.Automaton(states, counters, False, containing_state=None)
containerType._Automaton = _BuildAutomaton_26()
def _BuildAutomaton_27 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_27
del _BuildAutomaton_27
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 298, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12))
counters.add(cc_1)
cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12))
counters.add(cc_2)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(flowCalibratorType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 299, 16))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(flowCalibratorType._UseForTag(pyxb.namespace.ExpandedName(None, 'routeDistribution')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 300, 16))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(flowCalibratorType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_2, False))
symbol = pyxb.binding.content.ElementUse(flowCalibratorType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, False) ]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_2, True) ]))
st_3._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
flowCalibratorType._Automaton = _BuildAutomaton_27()
def _BuildAutomaton_28 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_28
del _BuildAutomaton_28
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 298, 12))
counters.add(cc_0)
cc_1 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12))
counters.add(cc_1)
cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12))
counters.add(cc_2)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(flowType._UseForTag(pyxb.namespace.ExpandedName(None, 'route')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 299, 16))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(flowType._UseForTag(pyxb.namespace.ExpandedName(None, 'routeDistribution')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 300, 16))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_1, False))
symbol = pyxb.binding.content.ElementUse(flowType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 302, 12))
st_2 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_2)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_2, False))
symbol = pyxb.binding.content.ElementUse(flowType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 303, 12))
st_3 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_3)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_0, False) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_0, False) ]))
st_1._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_2, [
fac.UpdateInstruction(cc_1, True) ]))
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_1, False) ]))
st_2._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_3, [
fac.UpdateInstruction(cc_2, True) ]))
st_3._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
flowType._Automaton = _BuildAutomaton_28()
def _BuildAutomaton_29 ():
# Remove this helper function from the namespace after it is invoked
global _BuildAutomaton_29
del _BuildAutomaton_29
import pyxb.utils.fac as fac
counters = set()
cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 488, 8))
counters.add(cc_0)
states = []
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(routeType._UseForTag(pyxb.namespace.ExpandedName(None, 'stop')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 489, 12))
st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_0)
final_update = set()
final_update.add(fac.UpdateInstruction(cc_0, False))
symbol = pyxb.binding.content.ElementUse(routeType._UseForTag(pyxb.namespace.ExpandedName(None, 'param')), pyxb.utils.utility.Location('http://sumo.dlr.de/xsd/routeTypes.xsd', 490, 12))
st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
states.append(st_1)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_0._set_transitionSet(transitions)
transitions = []
transitions.append(fac.Transition(st_0, [
fac.UpdateInstruction(cc_0, True) ]))
transitions.append(fac.Transition(st_1, [
fac.UpdateInstruction(cc_0, True) ]))
st_1._set_transitionSet(transitions)
return fac.Automaton(states, counters, True, containing_state=None)
routeType._Automaton = _BuildAutomaton_29()
| {
"repo_name": "TrafficSenseMSD/core",
"path": "ts_core/config/bindings/additional_xml.py",
"copies": "1",
"size": "726215",
"license": "epl-1.0",
"hash": 1775665385447303400,
"line_mean": 53.7549574003,
"line_max": 307,
"alpha_frac": 0.704862885,
"autogenerated": false,
"ratio": 3.366236354787123,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4571099239787123,
"avg_score": null,
"num_lines": null
} |
#additions of code for layer printing
#under line
#stream_auc = tf.contrib.metrics.streaming_auc(predictions = tf.round(tf.nn.sigmoid(pred)), labels = tf.round(y))
#
#added commands
image = tf.reshape(x, shape=[-1, 120, 120, 1])
h_conv1=conv2d(image, weights['wc1'], biases['bc1'])
#h_conv1_mp = maxpool2d(h_conv1, k=6)
h_conv2=conv2d(h_conv1, weights['wc2'], biases['bc2'])
#h_conv2_mp = maxpool2d(h_conv2, k=2)
h_conv3 = conv2d(h_conv2, weights['wc3'], biases['bc3'])
#modification of session run so as to acquire variables h_conv1,h_conv2,h_conv3
if step * batch_size % display_step == 0:
# Calculate batch loss and accuracy for train
train_loss, train_acc_c, train_acc, train_acc_pc, train_prec, train_rec, train_f1, train_auc, train_stream_auc, train_pred,h_conv1,h_conv2,h_conv3 = sess.run(
[cost, accuracy_calc, accuracy, accuracy_per_class, precision, recall, f1, auc, stream_auc,
tf.round(tf.nn.sigmoid(pred)),h_conv1,h_conv2,h_conv3], feed_dict={x: batch_x, y: batch_y, keep_prob: 1.})
#under command
#test_auc_print = test_auc[0]
#below code is added to save first image of each layer
for i in range(0,10):
img=Image.fromarray(batch_x[i,:,:])
img.save(str(i)+'init1.tiff')
for i in range(0,10):
img_conv1=h_conv1[i,:,:,1].reshape(120,120) #keep only 1 of 128 to show -otherwise use gif image to add all layers in one
img_conv1=Image.fromarray(img_conv1)
img_conv1.save(str(i)+'conv1.tiff')
for i in range(0,10):
img_conv2=h_conv2[i,:,:,1].reshape(120,120) #keep only 1 of 284 to show -otherwise use gif image to add all layers in one
img_conv2=Image.fromarray(img_conv2)
img_conv2.save(str(i)+'conv2.tiff')
for i in range(0,10):
img_conv3=h_conv3[i,:,:,1].reshape(120,120) #keep only 1 of 768 to show -otherwise use gif image to add all layers in one
img_conv3=Image.fromarray(img_conv3)
img_conv3.save(str(i)+'conv3.tiff')
| {
"repo_name": "emarkou/Audio-auto-tagging",
"path": "aux_layer_to_image_enhancement.py",
"copies": "1",
"size": "2186",
"license": "mit",
"hash": 8021023714165200000,
"line_mean": 48.8372093023,
"line_max": 170,
"alpha_frac": 0.6006404392,
"autogenerated": false,
"ratio": 2.9580514208389714,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4058691860038971,
"avg_score": null,
"num_lines": null
} |
# Additions that need to be made:
# 1) choose track to convert to binary. e.g. only piano, no drums
# 2) Correct the length of each note.
# 3) add in effects besides note on and note off
# 4) catch if conversion is out of bounds
import csv
import sys
import glob
# CSV file to read from
csv_file = 'morse.txt'
# File to write binary to
binary_output_file = 'outputBeet.txt'
# command line arguments optional:
# [prog name][readfile.txt(CSV)]
if len(sys.argv) > 1:
# use glob to catch * asterisks
# paths = glob.glob(sys.argv[1])
csv_file = sys.argv[1]
binary_output_file = csv_file + "bin"
# range of notes used 48 = C3, 72 = C5
# Inclusive range
lower_range = 30
upper_range = 90
# time divisor how fast track is printed
divisor = 10
past_note_list = [0] * (upper_range - lower_range + 1)
note_list = [None] * (upper_range - lower_range + 1)
file = open(csv_file, 'r')
csv_f = csv.reader(file)
# DATA STUCTURES
csv_array = []
csv_list_block = []
csv_dict = {}
# SETUP DATA STRUCTURES
for row in csv_f:
csv_array.append(row)
# song duration in midiclocks
duration = 0
for row in csv_array:
if int(row[1]) > duration:
duration = int(row[1])
lower_dict_range = 0
upper_dict_range = duration/100
# raw_input("pausing. press enter to continue")
j = 0
while upper_dict_range <= duration:
# print "started while"
i = 0
csv_list_block = []
for row in csv_array:
# print "started for"
if (int(row[1]) >= lower_dict_range) and (int(row[1]) < upper_dict_range):
csv_list_block.append(row)
# print row
i += 1
# print i
lower_dict_range = upper_dict_range
upper_dict_range += duration/100
csv_dict[j] = csv_list_block
j += 1
# COLLECTING AND WRITING
write_file = open(binary_output_file, 'w')
# using blocks of time as opposed to each individual time stamp to
# loop through unnecessary data. Should be 1000 times faster. exactly.
# no more, no less. any number out of bounds is unnaccetable
timestamp = 0 # keeps track of printed file number
dict_range = duration/100
for data_block_num in range(0, j):
data_block = csv_dict[data_block_num]
while timestamp < dict_range:
for note in range(lower_range, upper_range + 1):
for row in data_block:
# writing new notes
if (row[2] == " Note_on_c") \
and (int(row[1])/divisor == int(timestamp)) \
and (int(row[4]) == note):
note_list[note - lower_range] = 1
break
# removing old note
elif (row[2] == " Note_off_c") \
and (int(row[1])/divisor == int(timestamp)) \
and (int(row[4]) == note):
note_list[note - lower_range] = 0
break
# Holding past notes
elif past_note_list[note - lower_range] == 0:
note_list[note - lower_range] = 0
elif past_note_list[note - lower_range] == 1:
note_list[note - lower_range] = 1
else:
print "strange error"
timestamp += 1
# raw_input("Press Enter to exit")
past_note_list = list(note_list)
# write to screen
print "".join(map(str, note_list))
# write to file
# write_file.write(str("".join(map(str, note_list))) + '\n')
# print note_list
# sys.stdout.write('\n')
dict_range += duration/100
file.close()
write_file.close() | {
"repo_name": "spacerafe/Solenoise",
"path": "python3.py",
"copies": "1",
"size": "3725",
"license": "mit",
"hash": 295402787765278000,
"line_mean": 27.5793650794,
"line_max": 82,
"alpha_frac": 0.5551677852,
"autogenerated": false,
"ratio": 3.3987226277372264,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9434650628827456,
"avg_score": 0.0038479568219540847,
"num_lines": 126
} |
""" Additions to python's shutil standard library """
import fnmatch
import glob
import os
import shutil
import subprocess
import time
import zipfile
class SvnError(Exception):
pass
def svn_checkout(remote, local):
""" Check out repository 'remote' to 'local' path """
if subprocess.call(['svn', 'co', '-q', remote, local]) != 0:
raise SvnError('Error checking out' + remote)
def find_files(path, incl_patterns, excl_patterns=[], search_subdirs=False):
""" A more flexible way of finding a group of files than glob.glob().
Return a list of files under the given path that match
any of the include patterns, and none of the exclude patterns.
Optionally searches all subdirectories.
"""
# convert patterns to lists if they are not already
if type(incl_patterns) is not list:
incl_patterns = [incl_patterns]
if type(excl_patterns) is not list:
excl_patterns = [excl_patterns]
# find all filenames that match any include patterns
matches = []
num_dirs_searched = 0
for root, dirnames, filenames in os.walk(path):
if not search_subdirs and num_dirs_searched >= 1:
break
else:
for filename in filenames:
for pattern in incl_patterns:
if fnmatch.fnmatch(filename, pattern):
matches.append(os.path.join(root, filename))
break
num_dirs_searched += 1
# remove all filenames that match any exclude patterns
def isExcluded(filename):
for pattern in excl_patterns:
if fnmatch.fnmatch(filename, pattern):
return True
return False
return [x for x in matches if not isExcluded(os.path.basename(x))]
def unzip(archive_path, dest=None):
""" Extract the given zip archive, to present dir if no dest is given """
archive = zipfile.ZipFile(archive_path, 'r')
if dest is not None:
archive.extractall(dest)
else:
archive.extractall()
def zipdir(path, dest):
""" Zip all contents of path to dest """
zipf = zipfile.ZipFile(dest, 'w', compression=zipfile.ZIP_DEFLATED)
for root, dirs, files in os.walk(path):
for file in files:
zipf.write(os.path.join(root, file))
zipf.close()
def mkdirs(path):
""" Create the given directory if it doesn't already exist """
if not os.path.exists(path):
os.makedirs(path)
def copy_glob(pattern, dest):
""" Copy files by unix path pattern to the destination dir.
dest must be an existing directory, also if the pattern
returns directories, you're in trouble
"""
assert(os.path.isdir(dest))
items = glob.glob(pattern)
if len(items) == 0:
print 'warning: no files found in copy_glob. pattern: ' + pattern
else:
for item in items:
shutil.copy(item, dest)
def rmtree(path):
""" A wrapper for shutil.rmtree() since it sometimes fails
due to OS file handling delays (?). At least on windows it does.
"""
max_attempts = 3
attempts = 0
try:
shutil.rmtree(path)
attempts += 1
except:
if attempts < max_attempts:
time.sleep(0.5)
else:
raise Exception('rmtree failed after' + str(max_attempts) + 'attempts')
# sleep after removing tree as OS delays can cause errors
# shortly after this function
time.sleep(0.5)
if __name__ == '__main__':
print find_files('..', ['*.py'], search_subdirs=True)
| {
"repo_name": "uozuAho/doit_helpers",
"path": "doit_helpers/shutil2.py",
"copies": "1",
"size": "3559",
"license": "mit",
"hash": 4528998315549651500,
"line_mean": 28.9075630252,
"line_max": 83,
"alpha_frac": 0.6226468109,
"autogenerated": false,
"ratio": 4.062785388127854,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5185432199027854,
"avg_score": null,
"num_lines": null
} |
# Additive models
import random
from copy import copy
import numpy as np
from numpy.linalg import eigh
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plot
class AdditiveModel():
def __init__(self):
self.knots = None
self.X = None
self.Y = None
self.lambdas = None
self.S = None
self.B = None
self.X_aug = None
self.Y_aug = None
self.lr = None
self.X_names = None
self.Y_name = None
self.coefficients = None
self.original_coefficients = None
self.means = None
self.overall_mean = None
self.Y_predictions = None
self.Y_overall_prediction = None
def set_X(self,X):
self.X = X
def set_Y(self,Y):
self.Y = Y
def set_knots(self,knots):
self.knots = knots
def set_lambdas(self,lambdas):
self.lambdas = lambdas
def set_variable_names(self,X_names=None,Y_name=None):
self.X_names = X_names
self.Y_name = Y_name
def run(self):
self._build_S()
self._build_B()
self.build_X()
self._build_Y()
self.lr = LinearRegression()
self.lr.fit(self.X_aug,self.Y_aug)
self._generate_coefficients()
self._generate_predictions()
def plot(self):
number_of_rows,number_of_columns = self.X.shape
for i in xrange(number_of_columns):
X = self.X[:,i]
X_name = self.X_names[i]
predicted_Y = self.predicted_Y[i]
plot.xlabel(X_name)
plot.ylabel(self.Y_name)
plot.title('Variable '+str(i+1))
plot.scatter(X,self.Y,color='blue',s=0.5)
plot.scatter(X,predicted_Y[0:number_of_rows,0],color='orange',s=10.0)
plot.show()
plot.xlabel(X_name)
plot.ylabel('Residules')
plot.title('Variable '+str(i+1))
residules = predicted_Y[0:number_of_rows,:] - self.Y
plot.scatter(X,residules,color='blue',s=1.0)
plot.show()
all_predicted_Y = copy(self.predicted_Y[0])
for i in xrange(1,number_of_columns):
predicted_Y = self.predicted_Y[i]
all_predicted_Y = all_predicted_Y + predicted_Y - self.overall_mean
X = range(number_of_rows)
plot.xlabel('Data Item')
plot.ylabel('Residules')
plot.scatter(X,self.Y - all_predicted_Y[0:number_of_rows],color='blue',s=1.0)
plot.show()
def predict(self,X,Y,include_plot=False):
X_aug = self.build_X(X)
raw_predictions = []
predicted_Ys = []
number_of_rows = X_aug.shape[0] - self.B.shape[0]
number_of_columns = X.shape[1]
for i in xrange(number_of_columns):
coefficients = self.coefficients[i]
self.lr.coef_ = coefficients
raw_prediction = self.lr.predict(X_aug)
raw_predictions.append(raw_prediction)
self.overall_mean = float(sum(self.Y[:,0])/len(self.Y[:,0]))
for i in xrange(number_of_columns):
mean = self.means[i]
predicted_Y = raw_predictions[i] - mean + self.overall_mean
predicted_Ys.append(predicted_Y)
if include_plot:
number_of_rows,number_of_columns = X.shape
for i in xrange(number_of_columns):
X_col = X[:,i]
X_name = self.X_names[i]
predicted_Y = predicted_Ys[i]
plot.xlabel(X_name)
plot.ylabel(self.Y_name)
plot.title('Prediction')
plot.scatter(X_col,Y,color='blue',s=0.5)
plot.scatter(X_col,predicted_Y[0:number_of_rows,0],color='orange',s=10.0)
plot.show()
all_predicted_Y = copy(predicted_Ys[0])
for i in xrange(1,len(predicted_Ys)):
predicted_Y = predicted_Ys[i]
all_predicted_Y = all_predicted_Y + predicted_Y - self.overall_mean
errors = []
absolute_error = 0.0
number_of_rows = Y.shape[0]
for i in xrange(number_of_rows):
y_est = all_predicted_Y[i][0]
y_act = Y[i][0]
diff = y_act - y_est
errors.append(diff)
absolute_error = absolute_error + abs(diff)
prediction = (predicted_Ys,all_predicted_Y,errors,absolute_error)
return prediction
def _generate_predictions(self):
raw_predictions = []
self.predicted_Y = []
self.means = []
number_of_rows = self.X.shape[0]
for coefficients in self.coefficients:
self.lr.coef_ = coefficients
raw_prediction = self.lr.predict(self.X_aug)
raw_predictions.append(raw_prediction)
mean = float(sum(raw_prediction[0:number_of_rows,0])/len(raw_prediction[0:number_of_rows,0]))
self.means.append(mean)
self.overall_mean = float(sum(self.Y[:,0])/len(self.Y[:,0]))
l = len(raw_predictions)
for i in xrange(l):
mean = self.means[i]
predicted_Y = raw_predictions[i] - mean + self.overall_mean
self.predicted_Y.append(predicted_Y)
self.lr.coef_ = self.original_coefficients
self.Y_overall_prediction = self.lr.predict(self.X_aug)
def _generate_coefficients(self):
self.original_coefficients = copy(self.lr.coef_)
self.coefficients = []
offset = 2
offsets = []
for knots in self.knots:
offsets.append(offset)
offset = 1
indices = [0]
j_star = 0
for j in xrange(len(self.knots)):
knots = self.knots[j]
offset = offsets[j]
l = len(knots)
j_star = j_star + offset + l
indices.append(j_star)
for i in xrange(1,len(indices)):
start_i = indices[i-1]
end_i = indices[i]
number_of_columns = self.lr.coef_.shape[1]
new_coefficients = [[0.0]*number_of_columns]
for j in xrange(start_i,end_i):
new_coefficients[0][j] = self.lr.coef_[0][j]
new_coefficients = np.array(new_coefficients)
new_coefficients.resize((1,number_of_columns))
self.coefficients.append(new_coefficients)
def _build_S(self):
dim = 0
offset = 2
offsets = []
for knots in self.knots:
l = len(knots)
dim = dim + l + offset
offsets.append(offset)
offset = 1
self.S = np.array([0.0]*dim**2)
self.S.resize((dim,dim))
i_star = 0
j_star = 0
for inx in xrange(len(self.knots)):
knots = self.knots[inx]
offset = offsets[inx]
lamb = self.lambdas[inx]
i_star = i_star + offset
j_star = j_star + offset
S = np.array([0.0]*dim**2)
S.resize((dim,dim))
l = len(knots)
for i in xrange(0,l):
x_star_i = knots[i]
for j in xrange(0,l):
x_star_j = knots[j]
s = self._basis_function(x_star_i,x_star_j)
S[i_star+i][j_star+j] = s
i_star = i_star + i + 1
j_star = j_star + j + 1
self.S = self.S + lamb*S
def _build_B(self):
eigenvalues,eigenvectors = eigh(self.S)
l = eigenvalues.shape[0]
D = np.array([0.0]*l*l)
D.resize((l,l))
for i in xrange(l):
eigenvalue = eigenvalues[i]
D[i][i] = eigenvalue**0.5
self.B = np.dot(np.dot(eigenvectors,D),eigenvectors.T)
def build_X(self,X_est=None):
if X_est == None:
X = self.X
else:
X = X_est
offset = 2
offsets = []
for knots in self.knots:
offsets.append(offset)
offset = 1
number_of_rows,number_of_columns = X.shape
number_of_rows_B,number_of_columns_B = self.B.shape
number_of_rows_X = number_of_rows + number_of_rows_B
number_of_columns_X = number_of_columns_B
X_aug = np.array([1.0]*number_of_rows_X*number_of_columns_X)
X_aug.resize((number_of_rows_X,number_of_columns_X))
for i in xrange(number_of_rows):
j_star = 0
for j in xrange(number_of_columns):
x = X[i][j]
knots = self.knots[j]
offset = offsets[j]
j_star = j_star + offset
l = len(knots)
for inx in xrange(0,l):
knot = knots[inx]
s = self._basis_function(x,knot)
X_aug[i][j_star+inx] = s
X_aug[i][j_star-1] = x
j_star = j_star + inx + 1
for i in xrange(number_of_rows_B):
for j in xrange(number_of_columns_B):
b = self.B[i][j]
X_aug[i+number_of_rows][j] = b
if X_est == None:
self.X_aug = X_aug
else:
return X_aug
def _build_Y(self):
number_of_rows = self.Y.shape[0]
number_of_rows_B = self.B.shape[0]
number_of_rows_Y = number_of_rows + number_of_rows_B
self.Y_aug = np.array([0.0]*number_of_rows_Y)
self.Y_aug.resize((number_of_rows_Y,1))
for i in xrange(number_of_rows):
y = self.Y[i]
self.Y_aug[i] = y
def _basis_function(self,x_i,x_j):
result = (((x_j - 0.5)**2 - 1.0/12)*((x_i - 0.5)**2 - 1.0/12))/4.0 - ((abs(x_i - x_j) - 0.5)**4 - 0.5*(abs(x_i - x_j) - 0.5)**2 + 7.0/240)/24.0
return result
def generate_example_1(self,sample_size=1000):
X = []
Y = []
slope = 0.5
for i in xrange(sample_size):
x = i*3.0*np.pi/sample_size
y = 2.0*np.sin(x) + random.gauss(0,0.1)
X.append(x)
Y.append(y)
X = np.array(X)
X.resize((sample_size,1))
Y = np.array(Y)
Y.resize((sample_size,1))
self.set_X(X)
self.set_Y(Y)
self.set_knots([[0.2,0.4,0.6,0.8]])
self.set_lambdas([0.01])
self.run()
number_of_rows = self.X.shape[0]
plot.scatter(self.X,self.Y,color='blue',s=0.5)
predicted_Y = self.lr.predict(self.X_aug)
plot.scatter(self.X,predicted_Y[0:number_of_rows,0],color='orange',s=1.0)
plot.show()
residules = predicted_Y[0:number_of_rows,:] - self.Y
plot.scatter(self.X,residules,s=1.0,color='blue')
plot.show()
def generate_example_2(self,sample_size=1000):
X = []
Y = []
slope = 2.75
for i in xrange(sample_size):
x_1 = random.uniform(0,1)
x_2 = random.uniform(0,1)
x_3 = random.uniform(0,1)
y = 1.5*np.sin(2.0*np.pi*x_1) + 3.0*abs(np.cos(np.pi*(x_2-0.75))) + slope*x_3**2 + random.gauss(0,1.0)
X.append((x_1,x_2,x_3))
Y.append(y)
X = np.array(X)
X.resize((sample_size,3))
Y = np.array(Y)
Y.resize((sample_size,1))
self.set_X(X)
self.set_Y(Y)
self.set_knots([[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9],[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9],[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]])
self.set_lambdas([0.01,0.01,0.1])
self.set_variable_names(['X1','X2','X3'],'Response')
self.run()
self.plot()
def generate_example_3(self,sample_size=1000):
X_train = []
Y_train = []
X_test = []
Y_test = []
for i in xrange(sample_size):
x = random.uniform(0,1)
y = 3.0*abs(np.cos(np.pi*(x-0.75))) + random.gauss(0,1.0)
rand = random.uniform(0,1)
if rand < 0.20:
X_test.append(x)
Y_test.append(y)
else:
X_train.append(x)
Y_train.append(y)
X_train = np.array(X_train)
X_train.resize((len(X_train),1))
Y_train = np.array(Y_train)
Y_train.resize((len(Y_train),1))
X_test = np.array(X_test)
X_test.resize((len(X_test),1))
Y_test = np.array(Y_test)
Y_test.resize((len(Y_test),1))
self.set_X(X_train)
self.set_Y(Y_train)
self.set_knots([[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]])
self.set_lambdas([0.01])
self.set_variable_names(['X1'],'Response')
self.run()
self.plot()
val = self.predict(X_test,Y_test,True)
| {
"repo_name": "bsautrey/generalized-additive-models",
"path": "gam.py",
"copies": "1",
"size": "13243",
"license": "mit",
"hash": 67591255135136990,
"line_mean": 32.614213198,
"line_max": 151,
"alpha_frac": 0.4859925999,
"autogenerated": false,
"ratio": 3.253808353808354,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.42398009537083536,
"avg_score": null,
"num_lines": null
} |
# Additive number is a string whose digits can form additive sequence.
#
# A valid additive sequence should contain at least three numbers. Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.
#
# For example:
# "112358" is an additive number because the digits can form an additive sequence: 1, 1, 2, 3, 5, 8.
#
# 1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
# "199100199" is also an additive number, the additive sequence is: 1, 99, 100, 199.
# 1 + 99 = 100, 99 + 100 = 199
# Note: Numbers in the additive sequence cannot have leading zeros, so sequence 1, 2, 03 or 1, 02, 3 is invalid.
#
# Given a string containing only digits '0'-'9', write a function to determine if it's an additive number.
#
# Follow up:
# How would you handle overflow for very large input integers?
class Solution(object):
def isAdditiveNumber(self, num):
"""
:type num: str
:rtype: bool
"""
if len(num)< 2:
return False
first,second=0,0
for i in range(1,len(num)-1):
if num[0]=='0' and i>1:
break
for j in range(i+1,len(num)):
if num[i]=='0' and j>i+1:
break
first=int(num[0:i])
second=int(num[i:j])
k=j
while k<len(num):
result=str(first+second)
if num[k:].startswith(result):
first,second=second,int(result)
k+=len(result)
else:
break
if k==len(num):
return True
return False
so=Solution()
num="000"
print(so.isAdditiveNumber(num)) | {
"repo_name": "darrencheng0817/AlgorithmLearning",
"path": "Python/leetcode/AdditiveNumber.py",
"copies": "1",
"size": "1827",
"license": "mit",
"hash": 8526398470927179000,
"line_mean": 32.8518518519,
"line_max": 177,
"alpha_frac": 0.5249042146,
"autogenerated": false,
"ratio": 3.8463157894736844,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4871220004073684,
"avg_score": null,
"num_lines": null
} |
"""Additive recursion sequence."""
import numpy
def generalized_golden_ratio(dim):
"""
Using nested radical formula to calculate generalized golden ratio.
Args:
dim (int):
The number of dimension the ratio is to be used in.
Returns:
(float):
The generalize golden ratio for dimension `dim`.
Examples:
>>> generalized_golden_ratio(1)
1.618033988749895
>>> generalized_golden_ratio(2)
1.324717957244746
>>> generalized_golden_ratio(100)
1.0069208854344955
"""
out = 1.7
out_ = 1.
while out != out_:
out, out_ = out_, (1+out)**(1./(dim+1))
return out_
def create_additive_recursion_samples(order, dim=1, seed=0.5, alpha=None):
"""
Create samples from the additive recursion sequence.
Args:
order (int):
The number of samples to produce.
dim (int):
The number of dimensions in the sequence.
seed (float):
Random seed to be used in the sequence.
alpha (Optional[Sequence[float]]):
The (irrational) numbers used to create additive recursion.
If omitted, inverse of generalized golde-ratio values will be used.
Returns:
(numpy.ndarray):
Samples from the additive recursion sequence,
with shape `(dim, order)`.
Examples:
>>> chaospy.create_additive_recursion_samples(5, 1).round(4)
array([[0.118 , 0.7361, 0.3541, 0.9721, 0.5902]])
>>> chaospy.create_additive_recursion_samples(5, 2).round(4)
array([[0.2549, 0.0098, 0.7646, 0.5195, 0.2744],
[0.0698, 0.6397, 0.2095, 0.7794, 0.3492]])
>>> chaospy.create_additive_recursion_samples(5, 3).round(4)
array([[0.3192, 0.1383, 0.9575, 0.7767, 0.5959],
[0.171 , 0.8421, 0.5131, 0.1842, 0.8552],
[0.0497, 0.5994, 0.1491, 0.6988, 0.2485]])
"""
assert isinstance(dim, int) and dim > 0
assert 0 <= seed < 1
if alpha is None:
phi = generalized_golden_ratio(dim)
alpha = (1./phi)**numpy.arange(1, dim+1) % 1
assert isinstance(alpha, numpy.ndarray)
assert alpha.shape == (dim,)
return (seed+numpy.outer(alpha, numpy.arange(1, order+1))) % 1
| {
"repo_name": "jonathf/chaospy",
"path": "chaospy/distributions/sampler/sequences/additive_recursion.py",
"copies": "1",
"size": "2296",
"license": "mit",
"hash": -3687100003842804000,
"line_mean": 31.338028169,
"line_max": 79,
"alpha_frac": 0.581010453,
"autogenerated": false,
"ratio": 3.411589895988113,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4492600348988113,
"avg_score": null,
"num_lines": null
} |
"""Add job and schedule 's isDeleted fields.
Revision ID: 1b595e095951
Revises: b85f81a9f3cf
Create Date: 2016-08-04 20:25:24.702258
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '1b595e095951'
down_revision = 'b85f81a9f3cf'
def upgrade():
"""Add is job and schedule isDeleted fields."""
with op.batch_alter_table('job') as batch_op:
batch_op.add_column(sa.Column('isDeleted',
sa.Boolean(),
nullable=False,
server_default='false'))
with op.batch_alter_table('schedule') as batch_op:
batch_op.add_column(sa.Column('isDeleted',
sa.Boolean(),
nullable=False,
server_default='false'))
def downgrade():
"""Remove is job and schedule isDeleted fields."""
op.drop_column('schedule', 'isDeleted')
op.drop_column('job', 'isDeleted')
| {
"repo_name": "scattm/DanceCat",
"path": "migrations/versions/1b595e095951_.py",
"copies": "1",
"size": "1057",
"license": "mit",
"hash": 3715140251793046500,
"line_mean": 30.0882352941,
"line_max": 62,
"alpha_frac": 0.550614948,
"autogenerated": false,
"ratio": 3.973684210526316,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5024299158526315,
"avg_score": null,
"num_lines": null
} |
"""Add Jobs
Revision ID: 5da21d856a57
Revises: edd910853060
Create Date: 2017-07-30 16:43:35.839411
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '5da21d856a57'
down_revision = 'edd910853060'
branch_labels = None
depends_on = None
def upgrade():
op.create_table(
'jobs',
sa.Column('id', sa.Integer, primary_key=True, autoincrement=True),
sa.Column('command_name', sa.String(100), nullable=False),
sa.Column('parameters', sa.Text(), nullable=False),
sa.Column('schedule', sa.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('last_executed_at', sa.DateTime(timezone=True), nullable=True),
sa.Column('expired_at', sa.DateTime(timezone=True), nullable=True),
)
op.create_table(
'job_history',
sa.Column('id', sa.Integer, primary_key=True, autoincrement=True),
sa.Column('job_id', sa.Integer, nullable=False),
sa.Column('execution_id', sa.String(256), nullable=False),
sa.Column('executed_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('execution_ended', sa.DateTime(timezone=True), nullable=True),
sa.Column('results', sa.Text(), nullable=True),
sa.Column('result_type', sa.String(100), nullable=True),
)
def downgrade():
op.drop_table('jobs')
op.drop_table('job_history')
| {
"repo_name": "charlesj/Apollo",
"path": "database/versions/5da21d856a57_add_jobs.py",
"copies": "1",
"size": "1454",
"license": "mit",
"hash": 26698565045155436,
"line_mean": 32.0454545455,
"line_max": 81,
"alpha_frac": 0.6568088033,
"autogenerated": false,
"ratio": 3.342528735632184,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4499337538932184,
"avg_score": null,
"num_lines": null
} |
"""Add jobs table
Revision ID: 5706baf73b01
Revises: 6bd350cf4748
Create Date: 2016-09-14 15:53:50.394610
"""
# revision identifiers, used by Alembic.
revision = '5706baf73b01'
down_revision = '6bd350cf4748'
from alembic import op
import sqlalchemy as sa
import server
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('job',
sa.Column('created', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('updated', sa.DateTime(timezone=True), nullable=True),
sa.Column('status', sa.Enum('queued', 'running', 'finished', name='status'), nullable=False),
sa.Column('user_id', sa.Integer(), nullable=False),
sa.Column('course_id', sa.Integer(), nullable=False),
sa.Column('name', sa.String(length=255), nullable=False),
sa.Column('description', sa.Text(), nullable=False),
sa.Column('failed', sa.Boolean(), nullable=False),
sa.Column('log', sa.Text(), nullable=True),
sa.ForeignKeyConstraint(['course_id'], ['course.id'], name=op.f('fk_job_course_id_course')),
sa.ForeignKeyConstraint(['user_id'], ['user.id'], name=op.f('fk_job_user_id_user')),
sa.PrimaryKeyConstraint('id', name=op.f('pk_job'))
)
op.create_index(op.f('ix_job_course_id'), 'job', ['course_id'], unique=False)
op.create_index(op.f('ix_job_user_id'), 'job', ['user_id'], unique=False)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_job_user_id'), table_name='job')
op.drop_index(op.f('ix_job_course_id'), table_name='job')
op.drop_table('job')
### end Alembic commands ###
| {
"repo_name": "Cal-CS-61A-Staff/ok",
"path": "migrations/versions/5706baf73b01_add_jobs_table.py",
"copies": "1",
"size": "1741",
"license": "apache-2.0",
"hash": 5282669216772338000,
"line_mean": 37.6888888889,
"line_max": 102,
"alpha_frac": 0.6593911545,
"autogenerated": false,
"ratio": 3.177007299270073,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4336398453770073,
"avg_score": null,
"num_lines": null
} |
"""add_job_to_gen_task
Revision ID: 9aa153cb12a4
Revises: 1e0b1d3e3cca
Create Date: 2016-09-08 09:59:15.023182
"""
# revision identifiers, used by Alembic.
revision = '9aa153cb12a4'
down_revision = '1e0b1d3e3cca'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.add_column('file_generation_task', sa.Column('job_id', sa.Integer(), nullable=True))
op.create_foreign_key('fk_generation_job', 'file_generation_task', 'job', ['job_id'], ['job_id'])
op.drop_constraint('fk_publish_status_id', 'submission', type_='foreignkey')
op.create_foreign_key('fk_publish_status_id', 'submission', 'publish_status', ['publish_status_id'], ['publish_status_id'], ondelete='SET NULL')
### end Alembic commands ###
def downgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.drop_constraint('fk_publish_status_id', 'submission', type_='foreignkey')
op.create_foreign_key('fk_publish_status_id', 'submission', 'publish_status', ['publish_status_id'], ['publish_status_id'], ondelete='CASCADE')
op.drop_constraint('fk_generation_job', 'file_generation_task', type_='foreignkey')
op.drop_column('file_generation_task', 'job_id')
### end Alembic commands ###
| {
"repo_name": "fedspendingtransparency/data-act-broker-backend",
"path": "dataactcore/migrations/versions/9aa153cb12a4_add_job_to_gen_task.py",
"copies": "2",
"size": "1503",
"license": "cc0-1.0",
"hash": -1075958835865058400,
"line_mean": 31.6739130435,
"line_max": 148,
"alpha_frac": 0.6859614105,
"autogenerated": false,
"ratio": 3.267391304347826,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4953352714847826,
"avg_score": null,
"num_lines": null
} |
"""Add journal and submission spam filtering
Revision ID: 6f71a90cff21
Revises: 9270baf773a5
Create Date: 2019-08-31 00:56:04.057666
"""
# revision identifiers, used by Alembic.
revision = '6f71a90cff21'
down_revision = 'a48c39473126'
from alembic import op # lgtm[py/unused-import]
import sqlalchemy as sa # lgtm[py/unused-import]
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('journal', sa.Column('is_spam', sa.Boolean(), server_default='f', nullable=False))
op.add_column('journal', sa.Column('submitter_ip_address', sa.String(length=45), nullable=True))
op.add_column('journal', sa.Column('submitter_user_agent_id', sa.Integer(), nullable=True))
op.create_index('ind_journal_is_spam', 'journal', ['is_spam'], unique=False)
op.create_foreign_key('journal_user_agent_id_fkey', 'journal', 'user_agents', ['submitter_user_agent_id'], ['user_agent_id'], onupdate='CASCADE', ondelete='SET NULL')
op.add_column('submission', sa.Column('is_spam', sa.Boolean(), server_default='f', nullable=False))
op.add_column('submission', sa.Column('submitter_ip_address', sa.String(length=45), nullable=True))
op.add_column('submission', sa.Column('submitter_user_agent_id', sa.Integer(), nullable=True))
op.create_index('ind_submission_is_spam', 'submission', ['is_spam'], unique=False)
op.create_foreign_key('submission_agent_id_fkey', 'submission', 'user_agents', ['submitter_user_agent_id'], ['user_agent_id'], onupdate='CASCADE', ondelete='SET NULL')
# ### end Alembic commands ###
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.drop_constraint('submission_agent_id_fkey', 'submission', type_='foreignkey')
op.drop_index('ind_submission_is_spam', table_name='submission')
op.drop_column('submission', 'submitter_user_agent_id')
op.drop_column('submission', 'submitter_ip_address')
op.drop_column('submission', 'is_spam')
op.drop_constraint('journal_user_agent_id_fkey', 'journal', type_='foreignkey')
op.drop_index('ind_journal_is_spam', table_name='journal')
op.drop_column('journal', 'submitter_user_agent_id')
op.drop_column('journal', 'submitter_ip_address')
op.drop_column('journal', 'is_spam')
# ### end Alembic commands ###
| {
"repo_name": "Weasyl/weasyl",
"path": "libweasyl/libweasyl/alembic/versions/6f71a90cff21_add_journal_and_submission_spam_.py",
"copies": "1",
"size": "2307",
"license": "apache-2.0",
"hash": 9168968821777637000,
"line_mean": 51.4318181818,
"line_max": 171,
"alpha_frac": 0.6918075423,
"autogenerated": false,
"ratio": 3.23562412342216,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.442743166572216,
"avg_score": null,
"num_lines": null
} |
"""Add Keach
Revision ID: 53ed37276d53
Revises: cbef96b83a96
Create Date: 2017-10-21 12:50:07.872595
"""
from alembic import op # type: ignore
import sqlalchemy as sa # type: ignore
from sqlalchemy.sql import table, column # type: ignore
from typing import Tuple, List, Dict, Any # noqa
from mypy_extensions import TypedDict
from pathlib import Path
from json import load
# revision identifiers, used by Alembic.
revision = '53ed37276d53'
down_revision = 'cbef96b83a96'
branch_labels = None
depends_on = None
with (Path(__file__).resolve().parent / f'{revision}_keach.json').open() as f:
keach_data = load(f)
class QAJSON(TypedDict):
title: str
questions: List[List[str]]
def _get_qa_records(id: str, data: QAJSON) -> List[Dict[str, Any]]:
qas = [] # type: List[Dict[str, Any]]
for index in range(len(data['questions'])):
question, answer = data['questions'][index]
qas.append({'confess_id': id, 'question_number': index + 1,
'question_text': question, 'answer_text': answer})
return qas
confessions = table('confessions',
column('id', sa.Integer),
column('command', sa.String),
column('name', sa.String),
column('type_id', sa.Integer, sa.ForeignKey('confession_types.id')),
column('numbering_id', sa.Integer, sa.ForeignKey('confession_numbering_types.id')))
questions = table('confession_questions',
column('id', sa.Integer),
column('confess_id', sa.Integer, sa.ForeignKey('confessions.id')),
column('question_number', sa.Integer),
column('question_text', sa.Text),
column('answer_text', sa.Text))
def upgrade():
op.bulk_insert(confessions, [
{'id': 8, 'command': 'keach', 'type_id': 3, 'numbering_id': 1,
'name': 'Keach\'s Catechism'}
])
op.bulk_insert(questions, _get_qa_records(8, keach_data))
def downgrade():
conn = op.get_bind()
conn.execute(questions.delete().where(questions.c.confess_id == 8))
conn.execute(confessions.delete().where(confessions.c.id == 8))
| {
"repo_name": "bryanforbes/Erasmus",
"path": "alembic/versions/53ed37276d53_add_keach.py",
"copies": "1",
"size": "2182",
"license": "bsd-3-clause",
"hash": 5675630940486015000,
"line_mean": 30.6231884058,
"line_max": 103,
"alpha_frac": 0.6159486709,
"autogenerated": false,
"ratio": 3.430817610062893,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9544402799401015,
"avg_score": 0.0004726963123756135,
"num_lines": 69
} |
"""AddKeyToList
Adds/Updates a Key to a JSON-backed List
"""
import demistomock as demisto
from CommonServerPython import * # noqa # pylint: disable=unused-wildcard-import
from CommonServerUserPython import * # noqa
from typing import Dict, Any
import traceback
''' STANDALONE FUNCTION '''
def add_key_to_list(list_name: str, key_name: str, value: str, append: bool = False, allow_dups: bool = False) -> str:
res = demisto.executeCommand('getList', {'listName': list_name})
if (
not isinstance(res, list)
or 'Contents' not in res[0]
or not isinstance(res[0]['Contents'], str)
or res[0]['Contents'] == 'Item not found (8)'
):
raise ValueError(f'Cannot retrieve list {list_name}')
list_data: Dict = {}
data: str = res[0]['Contents']
if data and len(data) > 0:
try:
list_data = json.loads(data)
except json.decoder.JSONDecodeError as e:
raise ValueError(f'List does not contain valid JSON data: {e}')
if append and key_name in list_data:
entries: List = []
if isinstance(list_data[key_name], list):
entries = list_data[key_name]
else:
entries = [list_data[key_name]]
if value in entries and allow_dups is False:
return f'Value already present in key {key_name} of list {list_name}: not appending.'
entries.append(value)
list_data[key_name] = entries
else:
list_data[key_name] = value
demisto.executeCommand('setList', {'listName': list_name, 'listData': json.dumps(list_data)})
return f'Successfully updated list {list_name}.'
''' COMMAND FUNCTION '''
def add_key_to_list_command(args: Dict[str, Any]) -> CommandResults:
list_name = args.get('listName', None)
if not list_name:
raise ValueError('listName must be specified')
key_name = args.get('keyName', None)
if not key_name:
raise ValueError('keyName must be specified')
value = args.get('value', None)
if not value:
raise ValueError('value must be specified')
append = argToBoolean(args.get('append'))
allow_dups = argToBoolean(args.get('allowDups'))
# Call the standalone function and get the raw response
result = add_key_to_list(list_name, key_name, value, append, allow_dups)
return CommandResults(
readable_output=result
)
''' MAIN FUNCTION '''
def main():
try:
return_results(add_key_to_list_command(demisto.args()))
except Exception as ex:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute AddKeyToList. Error: {str(ex)}')
''' ENTRY POINT '''
if __name__ in ('__main__', '__builtin__', 'builtins'):
main()
| {
"repo_name": "demisto/content",
"path": "Packs/CommonScripts/Scripts/AddKeyToList/AddKeyToList.py",
"copies": "1",
"size": "2769",
"license": "mit",
"hash": -7223711860547449000,
"line_mean": 27.5463917526,
"line_max": 118,
"alpha_frac": 0.6309136873,
"autogenerated": false,
"ratio": 3.6243455497382198,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.47552592370382196,
"avg_score": null,
"num_lines": null
} |
"""add kingdoms
Revision ID: ea6f4ddd78a9
Revises: e7a0ff5cc43c
Create Date: 2016-09-27 15:06:14.662950
"""
# revision identifiers, used by Alembic.
revision = 'ea6f4ddd78a9'
down_revision = 'e7a0ff5cc43c'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('kingdom',
sa.Column('uuid', postgresql.UUID(as_uuid=True), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('created', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('updated', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('deleted', sa.DateTime(), nullable=True),
sa.Column('name', sa.String(length=256), nullable=False),
sa.Column('creator', sa.String(length=256), nullable=False),
sa.PrimaryKeyConstraint('uuid', name=op.f('pk_kingdom'))
)
op.create_table('kingdomcomment',
sa.Column('uuid', postgresql.UUID(as_uuid=True), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('created', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('updated', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('deleted', sa.DateTime(), nullable=True),
sa.Column('kingdom', postgresql.UUID(as_uuid=True), nullable=False),
sa.Column('author', sa.String(length=256), nullable=False),
sa.ForeignKeyConstraint(['kingdom'], ['kingdom.uuid'], name=op.f('fk_kingdomcomment_kingdom_kingdom')),
sa.PrimaryKeyConstraint('uuid', name=op.f('pk_kingdomcomment'))
)
op.create_table('kingdomrating',
sa.Column('uuid', postgresql.UUID(as_uuid=True), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('created', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('updated', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('deleted', sa.DateTime(), nullable=True),
sa.Column('kingdom', postgresql.UUID(as_uuid=True), nullable=False),
sa.Column('rating', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['kingdom'], ['kingdom.uuid'], name=op.f('fk_kingdomrating_kingdom_kingdom')),
sa.PrimaryKeyConstraint('uuid', name=op.f('pk_kingdomrating'))
)
op.create_table('kingdomcard',
sa.Column('uuid', postgresql.UUID(as_uuid=True), server_default=sa.text('gen_random_uuid()'), nullable=False),
sa.Column('created', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('updated', sa.DateTime(), server_default=sa.text('now()'), nullable=False),
sa.Column('deleted', sa.DateTime(), nullable=True),
sa.Column('kingdom', postgresql.UUID(as_uuid=True), nullable=False),
sa.Column('card', postgresql.UUID(as_uuid=True), nullable=False),
sa.ForeignKeyConstraint(['card'], ['card.uuid'], name=op.f('fk_kingdomcard_card_card')),
sa.ForeignKeyConstraint(['kingdom'], ['kingdom.uuid'], name=op.f('fk_kingdomcard_kingdom_kingdom')),
sa.PrimaryKeyConstraint('uuid', name=op.f('pk_kingdomcard'))
)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_table('kingdomcard')
op.drop_table('kingdomrating')
op.drop_table('kingdomcomment')
op.drop_table('kingdom')
### end Alembic commands ###
| {
"repo_name": "EliRibble/dominus",
"path": "alembic/versions/ea6f4ddd78a9_add_kingdoms.py",
"copies": "1",
"size": "3479",
"license": "mit",
"hash": -2927172798174804000,
"line_mean": 48.7,
"line_max": 114,
"alpha_frac": 0.686979017,
"autogenerated": false,
"ratio": 3.354869816779171,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.45418488337791707,
"avg_score": null,
"num_lines": null
} |
"""Add knowledge base
Revision ID: 15f55946909
Revises: 1dd1f9d85e2e
Create Date: 2014-11-15 22:09:02.701979
"""
# revision identifiers, used by Alembic.
revision = '15f55946909'
down_revision = '1dd1f9d85e2e'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.create_table('knowledgebase_article',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('parent', sa.Integer(), nullable=True),
sa.Column('name', sa.Text(), nullable=False),
sa.Column('title', sa.Text(), nullable=False),
sa.Column('content', sa.Text(), nullable=False),
sa.ForeignKeyConstraint(['parent'], ['knowledgebase_article.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('knowledgebase_article_revision',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('time', sa.DateTime(), nullable=False),
sa.Column('parent', sa.Integer(), nullable=True),
sa.Column('article_id', sa.Integer(), nullable=False),
sa.Column('title', sa.Text(), nullable=False),
sa.Column('content', sa.Text(), nullable=False),
sa.ForeignKeyConstraint(['article_id'], ['knowledgebase_article.id'], ),
sa.ForeignKeyConstraint(['parent'], ['knowledgebase_article_revision.id'], ),
sa.PrimaryKeyConstraint('id')
)
op.create_table('knowledgebase_article_rel_revision',
sa.Column('article', sa.Integer(), nullable=False),
sa.Column('revision', sa.Integer(), nullable=True),
sa.ForeignKeyConstraint(['article'], ['knowledgebase_article.id'], ),
sa.ForeignKeyConstraint(['revision'], ['knowledgebase_article_revision.id'], ),
sa.PrimaryKeyConstraint('article')
)
def downgrade():
op.drop_table('knowledgebase_article_rel_revision')
op.drop_table('knowledgebase_article_revision')
op.drop_table('knowledgebase_article')
| {
"repo_name": "404d/Temporals-Web",
"path": "temporals_web/migration/versions/201411152209_15f55946909_add_knowledge_base.py",
"copies": "2",
"size": "1813",
"license": "mit",
"hash": 6912378755666116000,
"line_mean": 35.26,
"line_max": 83,
"alpha_frac": 0.6872586873,
"autogenerated": false,
"ratio": 3.446768060836502,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.010047892447126706,
"num_lines": 50
} |
"""Add labels to component ports for lab measurements
"""
from typing import Callable, Optional, Union
import phidl.device_layout as pd
from phidl.device_layout import Label
import pp
from pp.component import Component, ComponentReference
from pp.port import Port
from pp.types import Layer
def get_optical_text(
port: Port,
gc: Union[ComponentReference, Component],
gc_index: Optional[int] = None,
component_name: Optional[str] = None,
) -> str:
"""Get text string for an optical port."""
polarization = gc.get_property("polarization")
wavelength_nm = gc.get_property("wavelength")
assert polarization in [
"te",
"tm",
], f"Not valid polarization {polarization} in [te, tm]"
assert (
isinstance(wavelength_nm, (int, float)) and 1000 < wavelength_nm < 2000
), f"{wavelength_nm} is Not valid 1000 < wavelength < 2000"
if component_name:
name = component_name
elif isinstance(port.parent, pp.Component):
name = port.parent.name
else:
name = port.parent.ref_cell.name
if isinstance(gc_index, int):
text = (
f"opt_{polarization}_{int(wavelength_nm)}_({name})_{gc_index}_{port.name}"
)
else:
text = f"opt_{polarization}_{int(wavelength_nm)}_({name})_{port.name}"
return text
def get_input_label(
port: Port,
gc: ComponentReference,
gc_index: Optional[int] = None,
gc_port_name: str = "W0",
layer_label: Layer = pp.LAYER.LABEL,
component_name: Optional[str] = None,
) -> Label:
"""Returns a label with component info for a given grating coupler.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
"""
text = get_optical_text(
port=port, gc=gc, gc_index=gc_index, component_name=component_name
)
if gc_port_name is None:
gc_port_name = list(gc.ports.values())[0].name
layer, texttype = pd._parse_layer(layer_label)
return pd.Label(
text=text,
position=gc.ports[gc_port_name].midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
def get_input_label_electrical(
port: Port,
gc_index: int = 0,
component_name: Optional[str] = None,
layer_label: Layer = pp.LAYER.LABEL,
gc: Optional[ComponentReference] = None,
) -> Label:
"""Returns a label to test component info for a given electrical port.
This is the label used by T&M to extract grating coupler coordinates
and match it to the component.
Args:
port:
gc_index: index of the label
component_name:
layer_label:
gc: ignored
"""
if component_name:
name = component_name
elif isinstance(port.parent, pp.Component):
name = port.parent.name
else:
name = port.parent.ref_cell.name
text = f"elec_{gc_index}_({name})_{port.name}"
layer, texttype = pd._parse_layer(layer_label)
label = pd.Label(
text=text,
position=port.midpoint,
anchor="o",
layer=layer,
texttype=texttype,
)
return label
def add_labels(
component: Component,
port_type: str = "dc",
get_label_function: Callable = get_input_label_electrical,
layer_label: Layer = pp.LAYER.LABEL,
gc: Optional[Component] = None,
) -> Component:
"""Add labels a particular type of ports
Args:
component: to add labels to
port_type: type of port ('dc', 'optical', 'electrical')
get_label_function: function to get label
layer_label: layer_label
Returns:
original component with labels
"""
ports = component.get_ports_list(port_type=port_type)
for i, port in enumerate(ports):
label = get_label_function(
port=port,
gc=gc,
gc_index=i,
component_name=component.name,
layer_label=layer_label,
)
component.add(label)
return component
def test_optical_labels() -> Component:
c = pp.components.straight()
gc = pp.components.grating_coupler_elliptical_te()
label1 = get_input_label(
port=c.ports["W0"], gc=gc, gc_index=0, layer_label=pp.LAYER.LABEL
)
label2 = get_input_label(
port=c.ports["E0"], gc=gc, gc_index=1, layer_label=pp.LAYER.LABEL
)
add_labels(c, port_type="optical", get_label_function=get_input_label, gc=gc)
labels_text = [c.labels[0].text, c.labels[1].text]
# print(label1)
# print(label2)
assert label1.text in labels_text, f"{label1.text} not in {labels_text}"
assert label2.text in labels_text, f"{label2.text} not in {labels_text}"
return c
def test_electrical_labels() -> Component:
c = pp.components.wire_straight()
label1 = get_input_label_electrical(
port=c.ports["E_1"], layer_label=pp.LAYER.LABEL, gc_index=0
)
label2 = get_input_label_electrical(
port=c.ports["E_0"], layer_label=pp.LAYER.LABEL, gc_index=1
)
add_labels(
component=c, port_type="dc", get_label_function=get_input_label_electrical
)
labels_text = [c.labels[0].text, c.labels[1].text]
assert label1.text in labels_text, f"{label1.text} not in {labels_text}"
assert label2.text in labels_text, f"{label2.text} not in {labels_text}"
return c
if __name__ == "__main__":
# c = test_optical_labels()
c = test_electrical_labels()
c.show()
| {
"repo_name": "gdsfactory/gdsfactory",
"path": "pp/add_labels.py",
"copies": "1",
"size": "5452",
"license": "mit",
"hash": -2949221566458281500,
"line_mean": 27.3958333333,
"line_max": 86,
"alpha_frac": 0.6254585473,
"autogenerated": false,
"ratio": 3.441919191919192,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4567377739219192,
"avg_score": null,
"num_lines": null
} |
""" Add language and time zone to user profile
Revision ID: 736f035d9c77
Revises: d0bbf6c460f5
Create Date: 2016-03-04 20:37:33.149292
"""
# revision identifiers, used by Alembic.
revision = '736f035d9c77'
down_revision = 'd0bbf6c460f5'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column('user', sa.Column('locale_id', sa.Integer(), nullable=True))
op.add_column('user', sa.Column('timezone_id', sa.Integer(), nullable=True))
op.create_foreign_key(None, 'user', 'enum_values', ['timezone_id'], ['id'])
op.create_foreign_key(None, 'user', 'enum_values', ['locale_id'], ['id'])
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_constraint(None, 'user', type_='foreignkey')
op.drop_constraint(None, 'user', type_='foreignkey')
op.drop_column('user', 'timezone_id')
op.drop_column('user', 'locale_id')
### end Alembic commands ###
| {
"repo_name": "betterlife/psi",
"path": "psi/migrations/versions/14_736f035d9c77_.py",
"copies": "2",
"size": "1032",
"license": "mit",
"hash": -3902110483951657000,
"line_mean": 31.25,
"line_max": 80,
"alpha_frac": 0.6676356589,
"autogenerated": false,
"ratio": 3.225,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.48926356589,
"avg_score": null,
"num_lines": null
} |
""" Add language column to projects
Revision ID: 219963bb18dc
Revises: 4f685c062cff
Create Date: 2015-09-21 18:06:53.922781
"""
# revision identifiers, used by Alembic.
revision = '219963bb18dc'
down_revision = '4f685c062cff'
from alembic import op
import sqlalchemy as sa
from models import JsonType
def upgrade():
op.add_column('project', sa.Column('languages', JsonType, nullable=True))
droptrigger = "DROP TRIGGER IF EXISTS tsvupdate_projects_trigger ON project"
droptriggerfunc = "DROP FUNCTION IF EXISTS project_search_trigger()"
createtriggerfunc = '''
CREATE FUNCTION project_search_trigger() RETURNS trigger AS $$
begin
new.tsv_body :=
setweight(to_tsvector('pg_catalog.english', coalesce(new.status,'')), 'A') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.tags,'')), 'A') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.name,'')), 'B') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.description,'')), 'B') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.languages,'')), 'A');
return new;
end
$$ LANGUAGE plpgsql;
'''
createtrigger = "CREATE TRIGGER tsvupdate_projects_trigger BEFORE INSERT OR UPDATE ON project FOR EACH ROW EXECUTE PROCEDURE project_search_trigger();"
op.execute(droptrigger)
op.execute(droptriggerfunc)
op.execute(createtriggerfunc)
op.execute(createtrigger)
def downgrade():
droptrigger = "DROP TRIGGER IF EXISTS tsvupdate_projects_trigger ON project"
droptriggerfunc = "DROP FUNCTION IF EXISTS project_search_trigger()"
createtriggerfunc = '''
CREATE FUNCTION project_search_trigger() RETURNS trigger AS $$
begin
new.tsv_body :=
setweight(to_tsvector('pg_catalog.english', coalesce(new.status,'')), 'A') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.tags,'')), 'A') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.name,'')), 'B') ||
setweight(to_tsvector('pg_catalog.english', coalesce(new.description,'')), 'B');
return new;
end
$$ LANGUAGE plpgsql;
'''
createtrigger = "CREATE TRIGGER tsvupdate_projects_trigger BEFORE INSERT OR UPDATE ON project FOR EACH ROW EXECUTE PROCEDURE project_search_trigger();"
op.execute(droptrigger)
op.execute(droptriggerfunc)
op.execute(createtriggerfunc)
op.execute(createtrigger)
op.drop_column('project', 'languages')
| {
"repo_name": "smalley/cfapi",
"path": "migrations/versions/219963bb18dc_add_language_column.py",
"copies": "3",
"size": "2579",
"license": "mit",
"hash": -1822151017231745800,
"line_mean": 39.9365079365,
"line_max": 155,
"alpha_frac": 0.6638231873,
"autogenerated": false,
"ratio": 3.547455295735901,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.005016523578835332,
"num_lines": 63
} |
"""Add languages
Revision ID: 2b963e6ca2a2
Revises: 3aac2c8dbcb6
Create Date: 2017-06-11 19:01:30.554383
"""
# revision identifiers, used by Alembic.
revision = '2b963e6ca2a2'
down_revision = '3aac2c8dbcb6'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column('UseLogs', sa.Column('all_languages', sa.Unicode(length=100), nullable=True))
op.add_column('UseLogs', sa.Column('first_language', sa.Unicode(length=10), nullable=True))
op.add_column('UseLogs', sa.Column('second_language', sa.Unicode(length=10), nullable=True))
op.add_column('UseLogs', sa.Column('third_language', sa.Unicode(length=10), nullable=True))
op.create_index(u'ix_UseLogs_all_languages', 'UseLogs', ['all_languages'], unique=False)
op.create_index(u'ix_UseLogs_first_language', 'UseLogs', ['first_language'], unique=False)
op.create_index(u'ix_UseLogs_second_language', 'UseLogs', ['second_language'], unique=False)
op.create_index(u'ix_UseLogs_third_language', 'UseLogs', ['third_language'], unique=False)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(u'ix_UseLogs_third_language', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_second_language', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_first_language', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_all_languages', table_name='UseLogs')
op.drop_column('UseLogs', 'third_language')
op.drop_column('UseLogs', 'second_language')
op.drop_column('UseLogs', 'first_language')
op.drop_column('UseLogs', 'all_languages')
### end Alembic commands ###
| {
"repo_name": "gateway4labs/labmanager",
"path": "alembic/versions/2b963e6ca2a2_add_languages.py",
"copies": "5",
"size": "1725",
"license": "bsd-2-clause",
"hash": -5746512356033352000,
"line_mean": 42.125,
"line_max": 96,
"alpha_frac": 0.7008695652,
"autogenerated": false,
"ratio": 3.096947935368043,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6297817500568043,
"avg_score": null,
"num_lines": null
} |
"""Add last check
Revision ID: 5ac5404bfcd9
Revises: 100cfe53a84
Create Date: 2015-05-11 18:13:41.180372
"""
# revision identifiers, used by Alembic.
revision = '5ac5404bfcd9'
down_revision = '100cfe53a84'
import datetime
from alembic import op
import sqlalchemy as sa
import sqlalchemy.sql as sql
import sys
sys.path.append('.')
from appcomposer.db import db
from appcomposer.application import app
metadata = db.MetaData()
translation_subscriptions = db.Table('TranslationSubscriptions', metadata,
db.Column('last_check', sa.DateTime())
)
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column('TranslationSubscriptions', sa.Column('last_check', sa.DateTime(), nullable=True))
op.create_index(u'ix_TranslationSubscriptions_last_check', 'TranslationSubscriptions', ['last_check'], unique=False)
### end Alembic commands ###
with app.app_context():
update_stmt = translation_subscriptions.update().where(translation_subscriptions.c.last_check == None).values(last_check = datetime.datetime.utcnow() - datetime.timedelta(hours = 72))
db.session.execute(update_stmt)
db.session.commit()
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(u'ix_TranslationSubscriptions_last_check', table_name='TranslationSubscriptions')
op.drop_column('TranslationSubscriptions', 'last_check')
### end Alembic commands ###
| {
"repo_name": "morelab/appcomposer",
"path": "alembic/versions/5ac5404bfcd9_add_last_check.py",
"copies": "3",
"size": "1453",
"license": "bsd-2-clause",
"hash": 4789112052578327000,
"line_mean": 31.2888888889,
"line_max": 191,
"alpha_frac": 0.7295251204,
"autogenerated": false,
"ratio": 3.6416040100250626,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.011242165285951598,
"num_lines": 45
} |
"""add last login to user table
Revision ID: cdcaa9c693e3
Revises: 608afa719fb8
Create Date: 2016-04-04 13:40:48.574963
"""
# revision identifiers, used by Alembic.
revision = 'cdcaa9c693e3'
down_revision = 'a04d38e74be3'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_error_data():
### commands auto generated by Alembic - please adjust! ###
pass
### end Alembic commands ###
def downgrade_error_data():
### commands auto generated by Alembic - please adjust! ###
pass
### end Alembic commands ###
def upgrade_job_tracker():
### commands auto generated by Alembic - please adjust! ###
pass
### end Alembic commands ###
def downgrade_job_tracker():
### commands auto generated by Alembic - please adjust! ###
pass
### end Alembic commands ###
def upgrade_user_manager():
### commands auto generated by Alembic - please adjust! ###
op.add_column('users', sa.Column('is_active', sa.Boolean(), server_default='True', nullable=False))
op.add_column('users', sa.Column('last_login_date', sa.DateTime(), nullable=True))
### end Alembic commands ###
def downgrade_user_manager():
### commands auto generated by Alembic - please adjust! ###
op.drop_column('users', 'last_login_date')
op.drop_column('users', 'is_active')
### end Alembic commands ###
| {
"repo_name": "fedspendingtransparency/data-act-core",
"path": "dataactcore/migrations/versions/cdcaa9c693e3_add_last_login_to_user_table.py",
"copies": "1",
"size": "1541",
"license": "cc0-1.0",
"hash": 4606191714504750600,
"line_mean": 22.3484848485,
"line_max": 103,
"alpha_frac": 0.6612589228,
"autogenerated": false,
"ratio": 3.6088992974238874,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.47701582202238874,
"avg_score": null,
"num_lines": null
} |
"""Add last_used_ip and use_count to tokens
Revision ID: 5cbb0eb12eb3
Revises: 1b7e98f581bc
Create Date: 2021-06-30 13:49:55.566636
"""
import sqlalchemy as sa
from alembic import op
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = '5cbb0eb12eb3'
down_revision = '1b7e98f581bc'
branch_labels = None
depends_on = None
def upgrade():
op.add_column('tokens', sa.Column('last_used_ip', postgresql.INET(), nullable=True), schema='users')
op.add_column('tokens', sa.Column('last_used_ip', postgresql.INET(), nullable=True), schema='oauth')
op.add_column('tokens', sa.Column('use_count', sa.Integer(), nullable=False, server_default='0'), schema='users')
op.add_column('tokens', sa.Column('use_count', sa.Integer(), nullable=False, server_default='0'), schema='oauth')
op.alter_column('tokens', 'use_count', server_default=None, schema='users')
op.alter_column('tokens', 'use_count', server_default=None, schema='oauth')
def downgrade():
op.drop_column('tokens', 'last_used_ip', schema='users')
op.drop_column('tokens', 'last_used_ip', schema='oauth')
op.drop_column('tokens', 'use_count', schema='users')
op.drop_column('tokens', 'use_count', schema='oauth')
| {
"repo_name": "indico/indico",
"path": "indico/migrations/versions/20210630_1349_5cbb0eb12eb3_add_last_used_ip_and_use_count_to_tokens.py",
"copies": "1",
"size": "1247",
"license": "mit",
"hash": 4977818263105297000,
"line_mean": 36.7878787879,
"line_max": 117,
"alpha_frac": 0.7000801925,
"autogenerated": false,
"ratio": 3.148989898989899,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4349070091489899,
"avg_score": null,
"num_lines": null
} |
# add LDDMM shooting code into path
import sys
sys.path.append('../../vectormomentum/Code/Python');
from subprocess import call
import argparse
import os.path
#Add LDDMM registration related libraries
# pyca modules
import PyCA.Core as ca
import PyCA.Common as common
import numpy as np
from skimage import exposure
parser = argparse.ArgumentParser(description='Perform preprocessing (affine transformation, intensity normalization (0 to 1) and histogram equalization (optional)) to input images')
requiredNamed = parser.add_argument_group('required named arguments')
requiredNamed.add_argument('--input-images', nargs='+', required=True, metavar=('i1', 'i2, i3...'),
help='List of input images, seperated by space.')
requiredNamed.add_argument('--output-images', nargs='+', required=True, metavar=('o1', 'o2, o3...'),
help='List of output image directory and file names, seperated by space. Do not save as .nii format as PyCA will flip the image. The recommended format to save images is .mhd')
parser.add_argument('--atlas', default="../../../data/atlas/icbm152.nii",
help="Atlas to use for (affine) pre-registration")
parser.add_argument('--input-labels', nargs='+', metavar=('l_i1', 'l_i2, l_i3...'),
help='List of input label maps for the input images, seperated by space.')
parser.add_argument('--output-labels', nargs='+', metavar=('l_o1', 'l_o2, l_o3...'),
help='List of output label maps, seperated by space.')
parser.add_argument('--histeq', action='store_true', default=False,
help='Perform histogram equalization to the moving and target images.')
args = parser.parse_args()
def check_args(args):
if (len(args.input_images) != len(args.output_images)):
print('The number of input images is not consistent with the number of output images!')
sys.exit(1)
if ((args.input_labels is None) ^ (args.output_labels is None)):
print('The input labels and output labels need to be both defined!')
sys.exit(1)
if ((args.input_labels is not None) and (len(args.input_labels) != len(args.output_labels))):
print('The number of input labels is not consistent with the number of output labels!')
def affine_transformation(args):
for i in range(0, len(args.input_images)):
call(["reg_aladin",
"-noSym", "-speeeeed", "-ref", args.atlas ,
"-flo", args.input_images[i],
"-res", args.output_images[i],
"-aff", args.output_images[i]+'_affine_transform.txt'])
if (args.input_labels is not None):
call(["reg_resample",
"-ref", args.atlas,
"-flo", args.input_labels[i],
"-res", args.output_labels[i],
"-trans", args.output_images[i]+'_affine_transform.txt',
"-inter", str(0)])
def intensity_normalization_histeq(args):
for i in range(0, len(args.input_images)):
image = common.LoadITKImage(args.output_images[i], ca.MEM_HOST)
grid = image.grid()
image_np = common.AsNPCopy(image)
nan_mask = np.isnan(image_np)
image_np[nan_mask] = 0
image_np /= np.amax(image_np)
# perform histogram equalization if needed
if args.histeq:
image_np[image_np != 0] = exposure.equalize_hist(image_np[image_np != 0])
image_result = common.ImFromNPArr(image_np, ca.MEM_HOST);
image_result.setGrid(grid)
common.SaveITKImage(image_result, args.output_images[i])
if __name__ == '__main__':
print((args.input_labels is None) and (args.output_labels is None))
affine_transformation(args);
intensity_normalization_histeq(args)
| {
"repo_name": "rkwitt/quicksilver",
"path": "code/tools/preprocessing/affine_and_histogram_eq.py",
"copies": "1",
"size": "3787",
"license": "apache-2.0",
"hash": 6391856064842232000,
"line_mean": 45.1829268293,
"line_max": 203,
"alpha_frac": 0.6329548455,
"autogenerated": false,
"ratio": 3.6910331384015596,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9753474757584389,
"avg_score": 0.01410264526343398,
"num_lines": 82
} |
# add LDDMM shooting code into path
import sys
sys.path.append('../vectormomentum/Code/Python')
sys.path.append('../library')
from subprocess import call
import argparse
import os.path
import gc
#Add deep learning related libraries
from collections import Counter
import torch
from torch.utils.serialization import load_lua
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
import prediction_network
import util
import numpy as np
#Add LDDMM registration related libraries
# library for importing LDDMM formulation configs
import yaml
# others
import logging
import copy
import math
#parse command line input
parser = argparse.ArgumentParser(description='Deformation predicting given set of moving and target images.')
##required parameters
requiredNamed = parser.add_argument_group('required named arguments')
requiredNamed.add_argument('--moving-image-dataset', nargs='+', required=True, metavar=('m1', 'm2, m3...'),
help='List of moving images datasets stored in .pth.tar format (or .t7 format for the old experiments in the Neuroimage paper). File names are seperated by space.')
requiredNamed.add_argument('--target-image-dataset', nargs='+', required=True, metavar=('t1', 't2, t3...'),
help='List of target images datasets stored in .pth.tar format (or .t7 format for the old experiments in the Neuroimage paper). File names are seperated by space.')
requiredNamed.add_argument('--deformation-parameter', nargs='+', required=True, metavar=('o1', 'o2, o3...'),
help='List of target deformation parameter files to predict to, stored in .pth.tar format (or .t7 format for the old experiments in the Neuroimage paper). File names are seperated by space.')
requiredNamed.add_argument('--deformation-setting-file', required=True, metavar=('yaml_file'),
help='yaml file that contains LDDMM registration settings.')
requiredNamed.add_argument('--output-name', required=True, metavar=('file_name'),
help='output directory + name of the network parameters, in .pth.tar format.')
##optional parameters
parser.add_argument('--features', type=int, default=64, metavar='N',
help='number of output features for the first layer of the deep network (default: 64)')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for prediction network (default: 64)')
parser.add_argument('--patch-size', type=int, default=15, metavar='N',
help='patch size to extract patches (default: 15)')
parser.add_argument('--stride', type=int, default=14, metavar='N',
help='sliding window stride to extract patches for training (default: 14)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train the network (default: 10)')
parser.add_argument('--learning-rate', type=float, default=0.0001, metavar='N',
help='learning rate for the adam optimization algorithm (default: 0.0001)')
parser.add_argument('--use-dropout', action='store_true', default=False,
help='Use dropout to train the probablistic version of the network')
parser.add_argument('--n-GPU', type=int, default=1, metavar='N',
help='number of GPUs used for training.')
parser.add_argument('--continue-from-parameter', metavar=('parameter_name'),
help='file directory+name of the existing parameter if want to start')
args = parser.parse_args()
# finish command line input
# check validity of input arguments from command line
def check_args(args):
# number of input images/output prefix consistency check
n_moving_images = len(args.moving_image_dataset)
n_target_images = len(args.target_image_dataset)
n_deformation_parameter = len(args.deformation_parameter)
if (n_moving_images != n_target_images):
print('The number of moving image datasets is not consistent with the number of target image datasets!')
sys.exit(1)
elif (n_moving_images != n_deformation_parameter ):
print('The number of moving image datasets is not consistent with the number of deformation parameter datasets!')
sys.exit(1)
# number of GPU check (positive integers)
if (args.n_GPU <= 0):
print('Number of GPUs must be positive!')
sys.exit(1)
#enddef
def read_spec(args):
stream = open(args.deformation_setting_file, 'r')
usercfg = yaml.load(stream, Loader = yaml.Loader)
return usercfg
#enddef
def create_net(args):
net_single = prediction_network.net(args.features, args.use_dropout).cuda();
if (args.continue_from_parameter != None):
print('Loading existing parameter file!')
config = torch.load(args.continue_from_parameter)
net_single.load_state_dict(config['state_dict'])
if (args.n_GPU > 1) :
device_ids=range(0, args.n_GPU)
net = torch.nn.DataParallel(net_single, device_ids=device_ids).cuda()
else:
net = net_single
net.train()
return net;
#enddef
def train_cur_data(cur_epoch, datapart, moving_file, target_file, parameter, output_name, net, criterion, optimizer, registration_spec, args):
old_experiments = False
if moving_file[-3:] == '.t7' :
old_experiments = True
#only for old data used in the Neuroimage paper. Do not use .t7 format for new data and new experiments.
moving_appear_trainset = load_lua(moving_file).float()
target_appear_trainset = load_lua(target_file).float()
train_m0 = load_lua(parameter).float()
else :
moving_appear_trainset = torch.load(moving_file).float()
target_appear_trainset = torch.load(target_file).float()
train_m0 = torch.load(parameter).float()
input_batch = torch.zeros(args.batch_size, 2, args.patch_size, args.patch_size, args.patch_size).cuda()
output_batch = torch.zeros(args.batch_size, 3, args.patch_size, args.patch_size, args.patch_size).cuda()
dataset_size = moving_appear_trainset.size()
flat_idx = util.calculatePatchIdx3D(dataset_size[0], args.patch_size*torch.ones(3), dataset_size[1:], args.stride*torch.ones(3));
flat_idx_select = torch.zeros(flat_idx.size());
for patch_idx in range(1, flat_idx.size()[0]):
patch_pos = util.idx2pos_4D(flat_idx[patch_idx], dataset_size[1:])
moving_patch = moving_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1]+args.patch_size, patch_pos[2]:patch_pos[2]+args.patch_size, patch_pos[3]:patch_pos[3]+args.patch_size]
target_patch = target_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1]+args.patch_size, patch_pos[2]:patch_pos[2]+args.patch_size, patch_pos[3]:patch_pos[3]+args.patch_size]
if (torch.sum(moving_patch) + torch.sum(target_patch) != 0):
flat_idx_select[patch_idx] = 1;
flat_idx_select = flat_idx_select.byte();
flat_idx = torch.masked_select(flat_idx, flat_idx_select);
N = flat_idx.size()[0] / args.batch_size;
for iters in range(0, N):
train_idx = (torch.rand(args.batch_size).double() * flat_idx.size()[0])
train_idx = torch.floor(train_idx).long()
for slices in range(0, args.batch_size):
patch_pos = util.idx2pos_4D(flat_idx[train_idx[slices]], dataset_size[1:])
input_batch[slices, 0] = moving_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1]+args.patch_size, patch_pos[2]:patch_pos[2]+args.patch_size, patch_pos[3]:patch_pos[3]+args.patch_size].cuda()
input_batch[slices, 1] = target_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1]+args.patch_size, patch_pos[2]:patch_pos[2]+args.patch_size, patch_pos[3]:patch_pos[3]+args.patch_size].cuda()
output_batch[slices] = train_m0[patch_pos[0], :, patch_pos[1]:patch_pos[1]+args.patch_size, patch_pos[2]:patch_pos[2]+args.patch_size, patch_pos[3]:patch_pos[3]+args.patch_size].cuda()
input_batch_variable = Variable(input_batch).cuda()
output_batch_variable = Variable(output_batch).cuda()
optimizer.zero_grad()
recon_batch_variable = net(input_batch_variable)
loss = criterion(recon_batch_variable, output_batch_variable)
loss.backward()
loss_value = loss.data[0]
optimizer.step()
print('====> Epoch: {}, datapart: {}, iter: {}/{}, loss: {:.4f}'.format(
cur_epoch+1, datapart+1, iters, N, loss_value/args.batch_size))
if iters % 100 == 0 or iters == N-1:
if args.n_GPU > 1:
cur_state_dict = net.module.state_dict()
else:
cur_state_dict = net.state_dict()
modal_name = output_name
model_info = {
'patch_size' : args.patch_size,
'network_feature' : args.features,
'state_dict': cur_state_dict,
'deformation_params': registration_spec
}
if old_experiments :
model_info['matlab_t7'] = True
#endif
torch.save(model_info, modal_name)
#enddef
def train_network(args, registration_spec):
net = create_net(args)
net.train()
criterion = nn.L1Loss(False).cuda()
optimizer = optim.Adam(net.parameters(), args.learning_rate)
for cur_epoch in range(0, args.epochs) :
for datapart in range(0, len(args.moving_image_dataset)) :
train_cur_data(
cur_epoch,
datapart,
args.moving_image_dataset[datapart],
args.target_image_dataset[datapart],
args.deformation_parameter[datapart],
args.output_name,
net,
criterion,
optimizer,
registration_spec,
args
)
gc.collect()
#enddef
if __name__ == '__main__':
check_args(args);
registration_spec = read_spec(args)
train_network(args, registration_spec)
| {
"repo_name": "rkwitt/quicksilver",
"path": "code/tools/qs_train.py",
"copies": "1",
"size": "9174",
"license": "apache-2.0",
"hash": 3026164173014974000,
"line_mean": 42.8947368421,
"line_max": 201,
"alpha_frac": 0.7135382603,
"autogenerated": false,
"ratio": 3.140705237932215,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9054296066977912,
"avg_score": 0.059989486250860716,
"num_lines": 209
} |
# add LDDMM shooting code into path
import sys
sys.path.append('../vectormomentum/Code/Python');
sys.path.append('../library')
from subprocess import call
import argparse
import os.path
#Add deep learning related libraries
from collections import Counter
import torch
import prediction_network
import util
import numpy as np
from skimage import exposure
#Add LDDMM registration related libraries
# pyca modules
import PyCA.Core as ca
import PyCA.Common as common
#import PyCA.Display as display
# vector momentum modules
# others
import logging
import copy
import math
import registration_methods
#parse command line input
parser = argparse.ArgumentParser(description='Deformation prediction given set of moving and target images.')
requiredNamed = parser.add_argument_group('required named arguments')
requiredNamed.add_argument('--moving-image', nargs='+', required=True, metavar=('m1', 'm2, m3...'),
help='List of moving images, seperated by space.')
requiredNamed.add_argument('--target-image', nargs='+', required=True, metavar=('t1', 't2, t3...'),
help='List of target images, seperated by space.')
requiredNamed.add_argument('--output-prefix', nargs='+', required=True, metavar=('o1', 'o2, o3...'),
help='List of registration output prefixes for every moving/target image pair, seperated by space. Preferred to be a directory (e.g. /some_path/output_dir/)')
parser.add_argument('--samples', type=int, default=50, metavar='N',
help='number of times to sample the network (default: 64)')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for prediction network (default: 64)')
parser.add_argument('--n-GPU', type=int, default=1, metavar='N',
help='number of GPUs used for prediction (default: 1). For maximum efficiency please set the batch size divisible by the number of GPUs.')
parser.add_argument('--use-CPU-for-shooting', action='store_true', default=False,
help='Use CPU for geodesic shooting. Slow, but saves GPU memory.')
parser.add_argument('--shoot-steps', type=int, default=0, metavar='N',
help='time steps for geodesic shooting. Ignore this option to use the default step size used by the registration model.')
parser.add_argument('--affine-align', action='store_true', default=False,
help='Perform affine registration to align moving and target images to ICBM152 atlas space. Require niftireg.')
parser.add_argument('--histeq', action='store_true', default=False,
help='Perform histogram equalization to the moving and target images.')
parser.add_argument('--atlas', default="../data/atlas/icbm152.nii",
help="Atlas to use for (affine) pre-registration")
parser.add_argument('--prediction-parameter', default='../../network_configs/OASIS_predict_probabilistic.pth.tar',
help="network parameters for the prediction network")
args = parser.parse_args()
# check validity of input arguments from command line
def check_args(args):
# number of input images/output prefix consistency check
n_moving_images = len(args.moving_image)
n_target_images = len(args.target_image)
n_output_prefix = len(args.output_prefix)
if (n_moving_images != n_target_images):
print('The number of moving images is not consistent with the number of target images!')
sys.exit(1)
elif (n_moving_images != n_output_prefix ):
print('The number of output prefix is not consistent with the number of input images!')
sys.exit(1)
# number of GPU check (positive integers)
if (args.n_GPU <= 0):
print('Number of GPUs must be positive!')
sys.exit(1)
# geodesic shooting step check (positive integers)
if (args.shoot_steps < 0):
print('Shooting steps (--shoot-steps) is negative. Using model default step.')
# geodesic shooting step check (positive integers)
if (args.samples < 1):
print('Number of samples (--samples) is smaller than 1. Using model default step.')
#enddef
def create_net(args, network_config):
net_single = prediction_network.net(network_config['network_feature']).cuda();
net_single.load_state_dict(network_config['state_dict'])
if (args.n_GPU > 1) :
device_ids=range(0, args.n_GPU)
net = torch.nn.DataParallel(net_single, device_ids=device_ids).cuda()
else:
net = net_single
net.train()
return net;
#enddef
def preprocess_image(image_pyca, histeq):
image_np = common.AsNPCopy(image_pyca)
nan_mask = np.isnan(image_np)
image_np[nan_mask] = 0
image_np /= np.amax(image_np)
# perform histogram equalization if needed
if histeq:
image_np[image_np != 0] = exposure.equalize_hist(image_np[image_np != 0])
return image_np
#perform deformation prediction
def predict_image(args):
if (args.use_CPU_for_shooting):
mType = ca.MEM_HOST
else:
mType = ca.MEM_DEVICE
# load the prediction network
predict_network_config = torch.load(args.prediction_parameter)
prediction_net = create_net(args, predict_network_config);
batch_size = args.batch_size
patch_size = predict_network_config['patch_size']
input_batch = torch.zeros(batch_size, 2, patch_size, patch_size, patch_size).cuda()
# start prediction
for i in range(0, len(args.moving_image)):
common.Mkdir_p(os.path.dirname(args.output_prefix[i]))
if (args.affine_align):
# Perform affine registration to both moving and target image to the ICBM152 atlas space.
# Registration is done using Niftireg.
call(["reg_aladin",
"-noSym", "-speeeeed", "-ref", args.atlas ,
"-flo", args.moving_image[i],
"-res", args.output_prefix[i]+"moving_affine.nii",
"-aff", args.output_prefix[i]+'moving_affine_transform.txt'])
call(["reg_aladin",
"-noSym", "-speeeeed" ,"-ref", args.atlas ,
"-flo", args.target_image[i],
"-res", args.output_prefix[i]+"target_affine.nii",
"-aff", args.output_prefix[i]+'target_affine_transform.txt'])
moving_image = common.LoadITKImage(args.output_prefix[i]+"moving_affine.nii", mType)
target_image = common.LoadITKImage(args.output_prefix[i]+"target_affine.nii", mType)
else:
moving_image = common.LoadITKImage(args.moving_image[i], mType)
target_image = common.LoadITKImage(args.target_image[i], mType)
#preprocessing of the image
moving_image_np = preprocess_image(moving_image, args.histeq);
target_image_np = preprocess_image(target_image, args.histeq);
grid = moving_image.grid()
moving_image_processed = common.ImFromNPArr(moving_image_np, mType)
target_image_processed = common.ImFromNPArr(target_image_np, mType)
moving_image.setGrid(grid)
target_image.setGrid(grid)
predict_transform_space = False
if 'matlab_t7' in predict_network_config:
predict_transform_space = True
# run actual prediction
prediction_result = util.predict_momentum(moving_image_np, target_image_np, input_batch, batch_size, patch_size, prediction_net, predict_transform_space);
m0 = prediction_result['image_space']
m0_reg = common.FieldFromNPArr(prediction_result['image_space'], mType);
registration_result = registration_methods.geodesic_shooting(moving_image_processed, target_image_processed, m0_reg, args.shoot_steps, mType, predict_network_config)
phi = common.AsNPCopy(registration_result['phiinv'])
phi_square = np.power(phi,2)
for sample_iter in range(1, args.samples):
print(sample_iter)
prediction_result = util.predict_momentum(moving_image_np, target_image_np, input_batch, batch_size, patch_size, prediction_net, predict_transform_space);
m0 += prediction_result['image_space']
m0_reg = common.FieldFromNPArr(prediction_result['image_space'], mType);
registration_result = registration_methods.geodesic_shooting(moving_image_processed, target_image_processed, m0_reg, args.shoot_steps, mType, predict_network_config)
phi += common.AsNPCopy(registration_result['phiinv'])
phi_square += np.power(common.AsNPCopy(registration_result['phiinv']),2)
m0_mean = np.divide(m0, args.samples);
m0_reg = common.FieldFromNPArr(m0_mean, mType);
registration_result = registration_methods.geodesic_shooting(moving_image_processed, target_image_processed, m0_reg, args.shoot_steps, mType, predict_network_config)
phi_mean = registration_result['phiinv']
phi_var = np.divide(phi_square, args.samples) - np.power(np.divide(phi, args.samples), 2)
#save result
common.SaveITKImage(registration_result['I1'], args.output_prefix[i]+"I1.mhd")
common.SaveITKField(phi_mean, args.output_prefix[i]+"phiinv_mean.mhd")
common.SaveITKField(common.FieldFromNPArr(phi_var, mType), args.output_prefix[i]+"phiinv_var.mhd")
#enddef
if __name__ == '__main__':
check_args(args);
predict_image(args)
| {
"repo_name": "rkwitt/quicksilver",
"path": "code/applications/qs_predict_probablistic.py",
"copies": "1",
"size": "9413",
"license": "apache-2.0",
"hash": 8798789634040187000,
"line_mean": 45.599009901,
"line_max": 185,
"alpha_frac": 0.6646127696,
"autogenerated": false,
"ratio": 3.654114906832298,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.48187276764322984,
"avg_score": null,
"num_lines": null
} |
"""Add legal entity city, county, and state info to PublishedAwardFinancialAssistance
Revision ID: 0ca75433c435
Revises: 18d9b114c1dc
Create Date: 2017-07-31 10:56:52.937763
"""
# revision identifiers, used by Alembic.
revision = '0ca75433c435'
down_revision = '18d9b114c1dc'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.add_column('published_award_financial_assistance', sa.Column('legal_entity_city_name', sa.Text(), nullable=True))
op.add_column('published_award_financial_assistance', sa.Column('legal_entity_county_code', sa.Text(), nullable=True))
op.add_column('published_award_financial_assistance', sa.Column('legal_entity_county_name', sa.Text(), nullable=True))
op.add_column('published_award_financial_assistance', sa.Column('legal_entity_state_code', sa.Text(), nullable=True))
op.add_column('published_award_financial_assistance', sa.Column('legal_entity_state_name', sa.Text(), nullable=True))
### end Alembic commands ###
def downgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.drop_column('published_award_financial_assistance', 'legal_entity_county_name')
op.drop_column('published_award_financial_assistance', 'legal_entity_county_code')
op.drop_column('published_award_financial_assistance', 'legal_entity_city_name')
op.drop_column('published_award_financial_assistance', 'legal_entity_state_code')
op.drop_column('published_award_financial_assistance', 'legal_entity_state_name')
### end Alembic commands ###
| {
"repo_name": "fedspendingtransparency/data-act-broker-backend",
"path": "dataactcore/migrations/versions/0ca75433c435_add_legal_entity_city_county_and_state_info_.py",
"copies": "1",
"size": "1814",
"license": "cc0-1.0",
"hash": 8372764542335311000,
"line_mean": 36.7916666667,
"line_max": 122,
"alpha_frac": 0.7271223815,
"autogenerated": false,
"ratio": 3.2450805008944545,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.44722028823944543,
"avg_score": null,
"num_lines": null
} |
"""Add legal_entity_congressional to detached and published award financial assistance tables
Revision ID: f57696aefcc1
Revises: 41350e71ae8c
Create Date: 2017-04-21 10:12:04.850729
"""
# revision identifiers, used by Alembic.
revision = 'f57696aefcc1'
down_revision = '41350e71ae8c'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.add_column('detached_award_financial_assistance', sa.Column('legal_entity_congressional', sa.Text(), nullable=True))
op.add_column('published_award_financial_assistance', sa.Column('legal_entity_congressional', sa.Text(), nullable=True))
### end Alembic commands ###
def downgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.drop_column('published_award_financial_assistance', 'legal_entity_congressional')
op.drop_column('detached_award_financial_assistance', 'legal_entity_congressional')
### end Alembic commands ###
| {
"repo_name": "fedspendingtransparency/data-act-broker-backend",
"path": "dataactcore/migrations/versions/f57696aefcc1_add_legal_entity_congressional_to_.py",
"copies": "1",
"size": "1206",
"license": "cc0-1.0",
"hash": 6793217650237457000,
"line_mean": 27.7142857143,
"line_max": 124,
"alpha_frac": 0.7247097844,
"autogenerated": false,
"ratio": 3.2861035422343323,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4510813326634332,
"avg_score": null,
"num_lines": null
} |
"""Add legal_entity_congressional to DetachedAwardFinancialAssistance table
Revision ID: c36ce06daaa1
Revises: 5f1470603fa0
Create Date: 2018-03-06 11:08:38.185497
"""
# revision identifiers, used by Alembic.
revision = 'c36ce06daaa1'
down_revision = '5f1470603fa0'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade(engine_name):
globals()["upgrade_%s" % engine_name]()
def downgrade(engine_name):
globals()["downgrade_%s" % engine_name]()
def upgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.add_column('detached_award_financial_assistance', sa.Column('legal_entity_congressional', sa.Text(), nullable=True))
op.create_index(op.f('ix_detached_award_financial_assistance_legal_entity_congressional'), 'detached_award_financial_assistance', ['legal_entity_congressional'], unique=False)
### end Alembic commands ###
def downgrade_data_broker():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(op.f('ix_detached_award_financial_assistance_legal_entity_congressional'), table_name='detached_award_financial_assistance')
op.drop_column('detached_award_financial_assistance', 'legal_entity_congressional')
### end Alembic commands ###
| {
"repo_name": "fedspendingtransparency/data-act-broker-backend",
"path": "dataactcore/migrations/versions/c36ce06daaa1_add_legal_entity_congressional_to_.py",
"copies": "1",
"size": "1297",
"license": "cc0-1.0",
"hash": -2346838504123981000,
"line_mean": 29.880952381,
"line_max": 179,
"alpha_frac": 0.734001542,
"autogenerated": false,
"ratio": 3.1634146341463416,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9249081088024846,
"avg_score": 0.029667017624299068,
"num_lines": 42
} |
"""Add LetterTemplates
Revision ID: 9005ab594598
Revises: 949aebe9e480
Create Date: 2018-03-20 18:41:57.143317
"""
# revision identifiers, used by Alembic.
revision = "9005ab594598"
down_revision = "949aebe9e480"
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table(
"letter_templates",
sa.Column("id", sa.Integer(), nullable=False),
sa.Column(
"type",
sa.Enum(
"acknowledgment",
"extension",
"closing",
"denial",
"re-opening",
"letters",
name="letter_type",
),
nullable=False,
),
sa.Column("agency_ein", sa.String(length=4), nullable=True),
sa.Column("title", sa.String(), nullable=False),
sa.Column("content", sa.String(), nullable=False),
sa.ForeignKeyConstraint(["agency_ein"], ["agencies.ein"]),
sa.PrimaryKeyConstraint("id"),
)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_table("letter_templates")
### end Alembic commands ###
| {
"repo_name": "CityOfNewYork/NYCOpenRecords",
"path": "migrations/versions/9005ab594598_add_lettertemplates.py",
"copies": "1",
"size": "1256",
"license": "apache-2.0",
"hash": 6739578341837139000,
"line_mean": 25.7234042553,
"line_max": 68,
"alpha_frac": 0.5644904459,
"autogenerated": false,
"ratio": 3.8646153846153846,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.49291058305153845,
"avg_score": null,
"num_lines": null
} |
add_library('box2d_processing')
# add_library('jbox2d')
class Box():
def __init__(self, box2d, x, y):
self.x = x
self.y = y
self.w = 16
self.h = 16
bd = BodyDef()
bd.type = BodyType.DYNAMIC
bd.position.set(box2d.coordPixelsToWorld(self.x, self.y))
self.body = box2d.createBody(bd)
sd = box2d.PolygonShape()
box2dW = box2d.scalarPixelsToWorld(self.w/2)
box2dH = box2d.scalarPixelsToWorld(self.h/2)
sd.setAsBox(box2dW, box2dH)
fd = FixtureDef()
fd.shape = sd
fd.density = 1
fd.friction = 0.3
fd.restitution = 0.5
self.body.createFixture(fd)
def display(self):
pos = box2d.getBodyPixelCoord(self.body)
a = self.body.getAngle()
with pushMatrix():
translate(pos.x, pos.y)
rotate(-a)
fill(175)
stroke(0)
rectMode(CENTER)
rect(0, 0, self.w, self.h)
| {
"repo_name": "kantel/processingpy",
"path": "sketches/box2dtest/box.py",
"copies": "1",
"size": "1050",
"license": "mit",
"hash": -8749425458108634000,
"line_mean": 25.25,
"line_max": 65,
"alpha_frac": 0.5085714286,
"autogenerated": false,
"ratio": 3.29153605015674,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.43001074787567395,
"avg_score": null,
"num_lines": null
} |
# Add lib/ to the import path:
import sys
import os
agent_lib_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../lib')
sys.path.insert(1, agent_lib_dir)
import re
import errno
from checks import AgentCheck
from helpers import reverse_readline
class OOM(AgentCheck):
def check(self, instance):
kernlogRE = re.compile(instance.get('kernel_line_regex'))
killedRE = re.compile(instance.get('kill_message_regex'), re.IGNORECASE)
last = None
try:
fh = open(instance.get('logfile'), 'rt')
except IOError, err:
if err.errno == errno.ENOENT:
level = AgentCheck.WARNING
else:
level = AgentCheck.CRITICAL
self.service_check('system.oom', level, message=str(err))
else:
last_killed = None
count = 0
with fh:
for line in reverse_readline(fh):
result = kernlogRE.match(line)
if not result:
continue
results = result.groupdict()
message = results['message']
if 'uptime' in results:
uptime = float(results['uptime'])
# only process lines since the last reboot -- we're processing backwards,
# so if we see an uptime larger than the last one we saw, it indicates
# a reboot (the current line is the lowest uptime in the current sequence)
#
# this is not entirely optimal for a filtered kernel log: it won't abort on
# equal timestamps, such as multiple reboot messages with timestamp 0, even
# though we would otherwise want to. if you filter your target log that heavily,
# though, it shouldn't be a problem -- and the complexity of capturing this case
# plus a full count of OOMs is not really worth the optimization
if last != None and uptime > last:
break
last = uptime
killed_match = killedRE.match(message)
if not killed_match:
continue
count += 1
last_killed = last_killed or killed_match
self.gauge('system.oom.count', count)
if last_killed == None:
self.service_check('system.oom', AgentCheck.OK)
else:
self.service_check('system.oom', AgentCheck.CRITICAL,
message="Process OOM killed since last boot: %s" % last_killed.groupdict()
)
| {
"repo_name": "stripe/stripe-datadog-checks",
"path": "checks.d/oom.py",
"copies": "2",
"size": "2792",
"license": "mit",
"hash": -4397761886110943700,
"line_mean": 36.2266666667,
"line_max": 104,
"alpha_frac": 0.5229226361,
"autogenerated": false,
"ratio": 4.86411149825784,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.6387034134357841,
"avg_score": null,
"num_lines": null
} |
# Add lib/ to the import path:
import sys
import os
agent_lib_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../lib')
sys.path.insert(1, agent_lib_dir)
import re
from checks import AgentCheck
from collections import defaultdict
from helpers import reverse_readline, parse_fix_timestamp
from datetime import datetime, timedelta
def regex_matches(line, regex):
if not line or not regex:
return
result = regex.match(line)
if not result:
return
return result.groupdict()
class Segfault(AgentCheck):
def tags(self, *tags):
return self.instance_tags + list(tags)
def check(self, instance):
self.instance_tags = instance.get('tags', [])
self.mock_now = instance.get('mock_now', None)
try:
# the regex to parse the kernel log line with
kernel_line_regex = re.compile(instance['kernel_line_regex'])
# the regex to extract the process name from the message with
process_name_regex = None
if 'process_name_regex' in instance and instance['process_name_regex']:
process_name_regex = re.compile(instance['process_name_regex'])
# the format to parse the timestamp from
# %b %d %H:%M:%S
timestamp_format = instance['timestamp_format']
# the number of seconds into the past to accumulate the count for
time_window_seconds = instance['time_window_seconds']
# the logfile to read from
logfile_path = instance['logfile']
except KeyError, e:
self.increment('system.segfault.errors', tags=self.tags('type:config'))
print >> sys.stderr, "Instance config: Key `%s` is required" % e.args[0]
return
except TypeError, e:
self.increment('system.segfault.errors', tags=self.tags('type:config'))
print >> sys.stderr, "Error loading config: %s" % e
return
try:
fh = open(logfile_path, 'rt')
except IOError, err:
self.increment('system.segfault.errors', tags=self.tags('type:io'))
return
counts = defaultdict(lambda: 0)
dt_now = self.mock_now or datetime.now()
dt_oldest = dt_now - timedelta(seconds=time_window_seconds)
with fh:
for line in reverse_readline(fh):
kern_results = regex_matches(line, kernel_line_regex)
# no match = skip this line
if not kern_results:
continue
message = kern_results.get('message', None)
timestamp = kern_results.get('timestamp', None)
try:
dt_timestamp = parse_fix_timestamp(timestamp, timestamp_format, dt_now)
except (ValueError, TypeError):
dt_timestamp = None
if message == None or dt_timestamp == None:
self.increment('system.segfault.errors', tags=self.tags('type:parse'))
continue
if dt_timestamp < dt_oldest:
# we only look back X seconds; we can end early if we hit a timestamp earlier than that
break
# process name regex is an extra regex to extract the process name
# from the 'message' capturing group. behaves the same as kernel_line_regex
# in that a failed match = skip this line. if unspecified, do not extract
# a process name
process_name = None
if process_name_regex:
pname_results = regex_matches(message, process_name_regex)
if not pname_results:
continue
process_name = pname_results.get('process', None)
counts[process_name] += 1
for pname, num_segfaults in counts.iteritems():
tags = ['time_window:%s' % time_window_seconds]
# sometimes the process name isn't present / can't be extracted
# we might want to put the process name in the tag config, so don't
# add on an extra 'process' tag that's empty in addition
if pname:
tags.append('process:%s' % pname)
metric_tags = self.tags(*tags)
self.gauge('system.segfault.count', num_segfaults, tags=metric_tags)
| {
"repo_name": "stripe/datadog-checks",
"path": "checks.d/segfault.py",
"copies": "2",
"size": "4433",
"license": "mit",
"hash": -5325803012039397000,
"line_mean": 36.8888888889,
"line_max": 107,
"alpha_frac": 0.5761335439,
"autogenerated": false,
"ratio": 4.406560636182903,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0037599700038505007,
"num_lines": 117
} |
# Add lib/ to the import path:
import sys
import os
agent_lib_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), '../lib')
sys.path.insert(1, agent_lib_dir)
# stdlib
from collections import namedtuple
import urlparse
import json
import time
import sys
# 3p
import requests
# project
from checks import AgentCheck
from util import headers
import re
import storm_utils
StormConfig = namedtuple(
'StormConfig',
[
'metric_prefix',
'tags',
'task_tags',
'timeout',
'executor_details_whitelist',
'topology_timeout',
'url',
'topologies',
'cache_file',
'cache_staleness',
'task_id_cleaner_regex',
]
)
class StormRESTCheck(AgentCheck):
class ConnectionFailure(StandardError):
def __init__(self, url, timeout):
self.url = url
self.timeout = timeout
DEFAULT_TIMEOUT = 5 # seconds
DEFAULT_STALENESS=240 # seconds
def instance_config(self, instance):
url = instance.get('url')
if url is None:
raise Exception("An url must be specified in the instance")
cache_file = instance.get('cache_file')
if cache_file is None:
raise Exception("You must specify a cache file (querying the storm API synchronously is too slow).")
timeout = instance.get('timeout', self.DEFAULT_TIMEOUT)
topology_timeout = instance.get('topology_timeout', timeout)
topologies_re = re.compile(instance.get('topologies', '(.*)'))
task_tags_from_json = {}
tag_file = instance.get('task_tags_file', None)
if tag_file is not None:
with open(tag_file, 'r') as f:
task_tags_from_json = json.load(f)
task_tags = instance.get('task_tags', {}).copy()
task_tags.update(task_tags_from_json)
raw_whitelist = set(instance.get('executor_details_whitelist', []))
executor_details_whitelist = [re.compile(regex) for regex in raw_whitelist]
return StormConfig(
metric_prefix=instance.get('metric_prefix', None),
url=url,
timeout=timeout,
topology_timeout=topology_timeout,
tags=instance.get('tags', []),
executor_details_whitelist=executor_details_whitelist,
task_tags=task_tags,
cache_file=cache_file,
cache_staleness=instance.get('cache_staleness', self.DEFAULT_STALENESS),
topologies=topologies_re,
task_id_cleaner_regex=instance.get('task_id_cleaner_regex', None),
)
def metric(self, config, name):
if config.metric_prefix is not None:
return "%s.storm.rest.%s" % (config.metric_prefix, name)
else:
return "storm.rest.%s" % name
def check(self, instance):
config = self.instance_config(instance)
check_status = AgentCheck.OK
check_msg = 'Everything went well'
check_tags = [
'url:' + config.url,
] + config.tags
details = None
with open(config.cache_file, 'r') as cache_f:
details = json.load(cache_f)
oldest_acceptable_cache_time = time.time() - config.cache_staleness
if details['status'] == 'success' and details['updated'] > oldest_acceptable_cache_time:
data = details['data']
self.report_cluster(config, data['cluster'])
self.report_supervisors(config, data['supervisors'])
self.report_topologies(config, data['topologies'])
for topology_detail in data['topology_details']:
self.report_topology(config, topology_detail['name'], topology_detail['topology'])
for executor_details in topology_detail['component_details']:
self.report_executor_details(config, executor_details)
else:
check_status = AgentCheck.CRITICAL
if details['status'] != 'success':
check_msg = "Could not connect to URL %s with timeout %d" % (details['error_url'], details['error_timeout'])
else:
check_msg = "Cache is too stale: %d vs. expected minimum %d" % (details['updated'], oldest_acceptable_cache_time)
self.service_check(
self.metric(config, 'cached_data_ok'),
check_status,
message=check_msg,
tags=check_tags)
def report_cluster(self, config, cluster):
uptime = cluster.get('nimbusUptime', None)
if uptime is not None:
self.gauge(self.metric(config, 'cluster.nimbus_uptime_seconds'),
storm_utils.translate_timespec(uptime),
tags=config.tags)
self.gauge(self.metric(config, 'cluster.slots_used_count'),
cluster['slotsUsed'],
tags=config.tags)
self.gauge(self.metric(config, 'cluster.supervisor_count'),
cluster['supervisors'],
tags=config.tags)
self.gauge(self.metric(config, 'cluster.slots_total_count'),
cluster['slotsTotal'],
tags=config.tags)
self.gauge(self.metric(config, 'cluster.slots_free_count'),
cluster['slotsFree'],
tags=config.tags)
self.gauge(self.metric(config, 'cluster.executors_total_count'),
cluster['executorsTotal'],
tags=config.tags)
self.gauge(self.metric(config, 'cluster.tasks_total_count'),
cluster['tasksTotal'],
tags=config.tags)
def report_supervisors(self, config, resp):
self.gauge(self.metric(config, 'supervisors_total'),
len(resp.get('supervisors', [])),
tags=config.tags)
for supe in resp.get('supervisors', []):
supe_tags = [
'storm_host:' + supe.get('host'),
] + config.tags
self.gauge(self.metric(config, 'supervisor.slots_total'),
supe.get('slotsTotal'), tags=supe_tags)
self.gauge(self.metric(config, 'supervisor.slots_used_total'),
supe.get('slotsUsed'), tags=supe_tags)
self.gauge(self.metric(config, 'supervisor.uptime_seconds'),
storm_utils.translate_timespec(supe.get('uptime')), tags=supe_tags)
def _topology_name(self, config, topology):
"""Returns the name if a config's topology regex matches, None otherwise."""
match = config.topologies.match(topology.get('name'))
if match:
return match.group(1)
else:
return None
def report_topologies(self, config, topologies):
"""Report metadata about topologies that match the topologies regex.
"""
for pretty_name, topo in topologies.iteritems():
uptime = topo.get('uptime', '0s')
tags = config.tags + [
'storm_topology:' + pretty_name,
]
self.gauge(self.metric(config, 'topologies.uptime_seconds'),
storm_utils.translate_timespec(uptime), tags=tags)
self.gauge(self.metric(config, 'topologies.tasks_total'),
topo['tasksTotal'], tags=tags)
self.gauge(self.metric(config, 'topologies.workers_total'),
topo['workersTotal'], tags=tags)
self.gauge(self.metric(config, 'topologies.executors_total'), topo['executorsTotal'], tags=tags)
def task_id_tags(self, config, component_type, task_id):
cleaner_id = task_id
if config.task_id_cleaner_regex is not None:
match = re.search(config.task_id_cleaner_regex, cleaner_id)
if match is not None:
cleaner_id = match.group(1)
return config.task_tags.get(component_type, {}).get(cleaner_id, [])
def report_topology(self, config, name, details):
"""
Report statistics for a single topology's spouts and bolts.
"""
tags = config.tags + [
'storm_topology:' + name,
]
def report_task(component_type, name, task, tags):
self.gauge(self.metric(config, ('%s.executors_total' % component_type)),
task['executors'], task_tags)
self.gauge(self.metric(config, ('%s.tasks_total' % component_type)),
task['tasks'], task_tags)
self.monotonic_count(self.metric(config, ('%s.emitted_total' % component_type)),
task['emitted'], task_tags)
self.monotonic_count(self.metric(config, ('%s.transferred_total' % component_type)),
task['transferred'], task_tags)
self.monotonic_count(self.metric(config, ('%s.acked_total' % component_type)),
task['acked'], task_tags)
self.monotonic_count(self.metric(config, ('%s.failed_total' % component_type)),
task['failed'], task_tags)
## Report spouts
for spout in details.get('spouts'):
name = spout['spoutId']
task_tags = tags + self.task_id_tags(config, 'spout', name) + [
'storm_component_type:spout',
'storm_task_id:' + name,
]
report_task('spout', name, spout, task_tags)
self.gauge(self.metric(config, 'spout.complete_latency_us'),
float(spout['completeLatency']), task_tags)
for bolt in details.get('bolts'):
name = bolt['boltId']
task_tags = tags + self.task_id_tags(config, 'bolt', name) + [
'storm_component_type:bolt',
'storm_task_id:' + name,
]
report_task('bolt', name, bolt, task_tags)
if bolt['executed'] is not None:
executed_count = bolt['executed']
else:
executed_count = 0
self.monotonic_count(self.metric(config, 'bolt.executed_total'),
executed_count, task_tags)
self.gauge(self.metric(config, 'bolt.execute_latency_us'),
float(bolt['executeLatency']), task_tags)
self.gauge(self.metric(config, 'bolt.process_latency_us'),
float(bolt['processLatency']), task_tags)
self.gauge(self.metric(config, 'bolt.capacity_percent'),
float(bolt['capacity']) * 100, task_tags)
def report_executor_details(self, config, details):
"""
Report statistics for a single topology's task ID's executors.
"""
topology_name = self._topology_name(config, details)
name = details['id']
task_type = details['componentType']
tags = config.tags + self.task_id_tags(config, task_type, name) + [
'storm_topology:' + topology_name,
'storm_component_type:' + task_type,
'storm_task_id:' + details['id'],
]
self.gauge(self.metric(config, 'executor.executors_total'),
details['executors'], tags=tags)
self.gauge(self.metric(config, 'executor.tasks_total'),
details['executors'], tags=tags)
# Embarrassingly, executorStats are undocumented in the REST
# API docs (so we might not be allowed to rely on them). But
# they're the only way to get some SERIOUSLY useful metrics -
# per-host metrics, in particular.
for executor in details['executorStats']:
executor_tags = tags + [
'executor_id:' + executor['id'],
'storm_host:' + executor['host'],
'storm_port:' + str(executor['port']),
]
self.monotonic_count(self.metric(config, 'executor.emitted_total'),
executor.get('emitted', 0), tags=executor_tags)
self.monotonic_count(self.metric(config, 'executor.transferred_total'),
executor.get('transferred', 0), tags=executor_tags)
self.monotonic_count(self.metric(config, 'executor.acked_total'),
executor.get('acked', 0), tags=executor_tags)
self.monotonic_count(self.metric(config, 'executor.executed_total'),
executor.get('executed', 0), tags=executor_tags)
self.monotonic_count(self.metric(config, 'executor.failed_total'),
executor.get('failed', 0), tags=executor_tags)
self.gauge(self.metric(config, 'executor.execute_latency_us'),
float(executor.get('executeLatency', 0)), tags=executor_tags)
self.gauge(self.metric(config, 'executor.process_latency_us'),
float(executor.get('processLatency', 0)), tags=executor_tags)
self.gauge(self.metric(config, 'executor.capacity_percent'),
float(executor.get('capacity', 0)) * 100, tags=executor_tags)
self.gauge(self.metric(config, 'executor.uptime_seconds'),
storm_utils.translate_timespec(executor.get('uptime', '0s')), tags=executor_tags)
| {
"repo_name": "stripe/stripe-datadog-checks",
"path": "checks.d/storm_rest_api.py",
"copies": "2",
"size": "13207",
"license": "mit",
"hash": 7086271769188336000,
"line_mean": 42.4440789474,
"line_max": 129,
"alpha_frac": 0.5700007572,
"autogenerated": false,
"ratio": 4.036369193154035,
"config_test": true,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.5606369950354034,
"avg_score": null,
"num_lines": null
} |
# add licence from base project ? or wait til we've modified everything :P ?
from PIL import Image
import logging
class ImageFormatter:
def __init__(self, image_path):
self.image_path = image_path
try:
self.image = Image.open(image_path)
except IOError:
logging.info("Unable to open image " + image_path)
raise IOError
def process_image(self, side):
self.__crop_image()
self.__resize_image(side,side)
self.__black_and_white()
return self.__get_main_color_black()
def save_image(self, image_path):
self.image.save(image_path)
def get_image(self):
return self.image
"""
Crop input image so that you get a square image (no resize yet, only crop)
NOT TESTED (and it should be)
"""
def __crop_image(self):
im_width, im_height = self.image.size
hWidth = im_width / 2
hHeight = im_height / 2
minSide = im_width
if im_width > im_height:
minSide = im_height
minSide = minSide / 2
self.image = self.image.crop((int(hWidth - minSide), int(hHeight - minSide), int(hWidth + minSide), int(hHeight + minSide)))
# I guess this will be used only at the beginning, then we should switch to colours.
def __black_and_white(self):
self.image = self.image.convert('L')
def __get_main_color(self):
# For now, it uses the function from base-project
r = 0
g = 0
b = 0
count = 0
pix = self.image.load()
im_max_x, im_max_y = self.image.size
for x in range(0, im_max_x):
for y in range(0, im_max_y):
temp_r, temp_g, temp_b = pix[x,y]
r += temp_r
g += temp_g
b += temp_b
count += 1
return float(r) / float(count), float(g) / float(count), float(b) / float(count)
def __get_main_color_black(self):
# For now, it uses the function from base-project
b = 0
count = 0
pix = self.image.load()
im_max_x, im_max_y = self.image.size
for x in range(0, im_max_x):
for y in range(0, im_max_y):
temp_b = pix[x,y]
b += temp_b
count += 1
return float(b) / float(count)
"""
resize input image so that it can be saved and then directly used in a mosaic if needed.
Recommanded size 5x5px (not sure though) -> warning: we must also keep a good quality image, so that
user can zoom in on the smartphone and get the bigger image.
"""
def __resize_image(self, w, h):
self.image = self.image.resize((int(w),int(h)), Image.ANTIALIAS) | {
"repo_name": "insacloud/insacloud-back",
"path": "insacloud/services/mosaic/ImageFormatter.py",
"copies": "1",
"size": "2773",
"license": "mit",
"hash": -2944896209923318300,
"line_mean": 27.8958333333,
"line_max": 132,
"alpha_frac": 0.5517490083,
"autogenerated": false,
"ratio": 3.6201044386422976,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.46718534469422973,
"avg_score": null,
"num_lines": null
} |
"""Add linkage model to the DB.
Revision ID: aac638b04072
Revises: a8849e4e6784
Create Date: 2019-12-21 19:47:17.878084
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = "aac638b04072"
down_revision = "a8849e4e6784"
def upgrade():
op.create_table(
"linkage",
sa.Column("created_at", sa.DateTime(), nullable=True), # noqa
sa.Column("updated_at", sa.DateTime(), nullable=True),
sa.Column("id", sa.BigInteger(), nullable=False),
sa.Column("profile_id", sa.String(length=128), nullable=True),
sa.Column("entity_id", sa.String(length=128), nullable=True),
sa.Column("collection_id", sa.Integer(), nullable=True),
sa.Column("decision", sa.Boolean(), nullable=True),
sa.Column("decider_id", sa.Integer()),
sa.Column("context_id", sa.Integer()),
sa.ForeignKeyConstraint(["collection_id"], ["collection.id"],),
sa.ForeignKeyConstraint(["context_id"], ["role.id"],),
sa.ForeignKeyConstraint(["decider_id"], ["role.id"],),
sa.PrimaryKeyConstraint("id"),
)
op.create_index(
op.f("ix_linkage_collection_id"), "linkage", ["collection_id"], unique=False
) # noqa
op.create_index(
op.f("ix_linkage_profile_id"), "linkage", ["profile_id"], unique=False
) # noqa
op.create_index(
op.f("ix_linkage_entity_id"), "linkage", ["entity_id"], unique=False
) # noqa
def downgrade():
op.drop_table("linkage")
| {
"repo_name": "alephdata/aleph",
"path": "aleph/migrate/versions/aac638b04072_add_linkage.py",
"copies": "1",
"size": "1518",
"license": "mit",
"hash": -5231175847084169000,
"line_mean": 32.7333333333,
"line_max": 84,
"alpha_frac": 0.6251646904,
"autogenerated": false,
"ratio": 3.343612334801762,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9467469835659279,
"avg_score": 0.000261437908496732,
"num_lines": 45
} |
"""add link between sample and case
Revision ID: 2f5352038e54
Revises: 156d2138ea8b
Create Date: 2017-02-07 11:06:17.737229
"""
# revision identifiers, used by Alembic.
revision = "2f5352038e54"
down_revision = "156d2138ea8b"
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import mysql
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column("sample", sa.Column("case_id", sa.Integer(), nullable=True))
op.create_foreign_key(None, "sample", "case", ["case_id"], ["id"])
op.drop_column("sample", "customer")
op.drop_column("sample", "family_id")
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column(
"sample", sa.Column("family_id", mysql.VARCHAR(length=128), nullable=False)
)
op.add_column(
"sample", sa.Column("customer", mysql.VARCHAR(length=32), nullable=False)
)
op.drop_constraint(None, "sample", type_="foreignkey")
op.drop_column("sample", "case_id")
### end Alembic commands ###
| {
"repo_name": "Clinical-Genomics/housekeeper",
"path": "alembic/versions/2f5352038e54_add_link_between_sample_and_case.py",
"copies": "1",
"size": "1132",
"license": "mit",
"hash": 3860723140657662500,
"line_mean": 28.0256410256,
"line_max": 83,
"alpha_frac": 0.6696113074,
"autogenerated": false,
"ratio": 3.309941520467836,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.4479552827867836,
"avg_score": null,
"num_lines": null
} |
"""Add list and cards tables
Revision ID: 1c1883fada8
Revises: 18554c40c9e
Create Date: 2015-04-08 20:24:35.892248
"""
# revision identifiers, used by Alembic.
revision = '1c1883fada8'
down_revision = '18554c40c9e'
branch_labels = None
depends_on = None
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.create_table('list',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
sa.Column('modified_at', sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
sa.Column('name', sa.UnicodeText(), nullable=False),
sa.PrimaryKeyConstraint('id')
)
op.create_table('card',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
sa.Column('modified_at', sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
sa.Column('translation_id', sa.Integer(), nullable=False),
sa.Column('list_id', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['list_id'], ['list.id'], ),
sa.ForeignKeyConstraint(['translation_id'], ['translation.id'], ),
sa.PrimaryKeyConstraint('id')
)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_table('card')
op.drop_table('list')
### end Alembic commands ###
| {
"repo_name": "lizardschool/wordbook",
"path": "migrations/versions/1c1883fada8_add_list_and_cards_tables.py",
"copies": "1",
"size": "1543",
"license": "mit",
"hash": -454381980561097100,
"line_mean": 33.2888888889,
"line_max": 103,
"alpha_frac": 0.6785482826,
"autogenerated": false,
"ratio": 3.398678414096916,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.9528866799050575,
"avg_score": 0.009671979529268312,
"num_lines": 45
} |
"""Add local time
Revision ID: 56d38b1172f9
Revises: 3999a40ec7b
Create Date: 2017-06-09 19:31:20.999843
"""
# revision identifiers, used by Alembic.
revision = '56d38b1172f9'
down_revision = '3999a40ec7b'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic - please adjust! ###
op.add_column('UseLogs', sa.Column('local_date', sa.Date(), nullable=False))
op.add_column('UseLogs', sa.Column('local_day_of_week', sa.Integer(), nullable=False))
op.add_column('UseLogs', sa.Column('local_hour_of_day', sa.Integer(), nullable=False))
op.add_column('UseLogs', sa.Column('local_month', sa.Integer(), nullable=False))
op.add_column('UseLogs', sa.Column('local_year', sa.Integer(), nullable=False))
op.create_index(u'ix_UseLogs_local_date', 'UseLogs', ['local_date'], unique=False)
op.create_index(u'ix_UseLogs_local_day_of_week', 'UseLogs', ['local_day_of_week'], unique=False)
op.create_index(u'ix_UseLogs_local_hour_of_day', 'UseLogs', ['local_hour_of_day'], unique=False)
op.create_index(u'ix_UseLogs_local_month', 'UseLogs', ['local_month'], unique=False)
op.create_index(u'ix_UseLogs_local_year', 'UseLogs', ['local_year'], unique=False)
### end Alembic commands ###
def downgrade():
### commands auto generated by Alembic - please adjust! ###
op.drop_index(u'ix_UseLogs_local_year', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_local_month', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_local_hour_of_day', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_local_day_of_week', table_name='UseLogs')
op.drop_index(u'ix_UseLogs_local_date', table_name='UseLogs')
op.drop_column('UseLogs', 'local_year')
op.drop_column('UseLogs', 'local_month')
op.drop_column('UseLogs', 'local_hour_of_day')
op.drop_column('UseLogs', 'local_day_of_week')
op.drop_column('UseLogs', 'local_date')
### end Alembic commands ###
| {
"repo_name": "gateway4labs/labmanager",
"path": "alembic/versions/56d38b1172f9_add_local_time.py",
"copies": "5",
"size": "1964",
"license": "bsd-2-clause",
"hash": -575874088971928600,
"line_mean": 43.6363636364,
"line_max": 100,
"alpha_frac": 0.6822810591,
"autogenerated": false,
"ratio": 2.9096296296296296,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.006568649952752296,
"num_lines": 44
} |
"""add local_user_id
Revision ID: 57bbf0c387c
Revises: 13391c68750
Create Date: 2016-04-02 09:54:09.643644
"""
from __future__ import unicode_literals
import sqlalchemy as sa
from alembic import op
from sqlalchemy.sql import table
# revision identifiers, used by Alembic.
revision = "57bbf0c387c"
down_revision = "13391c68750"
def upgrade():
conn = op.get_bind()
op.add_column("external_identities", sa.Column("local_user_id", sa.Integer()))
external_identities_t = table(
"external_identities",
sa.Column("local_user_name", sa.Unicode(50)),
sa.Column("local_user_id", sa.Integer),
)
users_t = table(
"users", sa.Column("user_name", sa.Unicode(50)), sa.Column("id", sa.Integer)
)
stmt = (
external_identities_t.update()
.values(local_user_id=users_t.c.id)
.where(users_t.c.user_name == external_identities_t.c.local_user_name)
)
conn.execute(stmt)
op.drop_constraint("pk_external_identities", "external_identities", type_="primary")
op.drop_constraint(
"fk_external_identities_local_user_name_users",
"external_identities",
type_="foreignkey",
)
op.drop_column("external_identities", "local_user_name")
op.create_primary_key(
"pk_external_identities",
"external_identities",
columns=["external_id", "local_user_id", "provider_name"],
)
op.create_foreign_key(
None,
"external_identities",
"users",
remote_cols=["id"],
local_cols=["local_user_id"],
onupdate="CASCADE",
ondelete="CASCADE",
)
def downgrade():
pass
| {
"repo_name": "ergo/ziggurat_foundations",
"path": "ziggurat_foundations/migrations/versions/57bbf0c387c_add_local_user_id.py",
"copies": "1",
"size": "1653",
"license": "bsd-3-clause",
"hash": 703831136301463600,
"line_mean": 25.6612903226,
"line_max": 88,
"alpha_frac": 0.6261343013,
"autogenerated": false,
"ratio": 3.312625250501002,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.44387595518010015,
"avg_score": null,
"num_lines": null
} |
"""Add Locate control to folium Map.
Based on leaflet plugin: https://github.com/domoritz/leaflet-locatecontrol
"""
from branca.element import MacroElement
from folium.elements import JSCSSMixin
from folium.utilities import parse_options
from jinja2 import Template
class LocateControl(JSCSSMixin, MacroElement):
"""Control plugin to geolocate the user.
This plugins adds a button to the map, and when it's clicked shows the current
user device location.
To work properly in production, the connection needs to be encrypted, otherwise browser will not
allow users to share their location.
Parameters
----------
auto-start : bool, default False
When set to True, plugin will be activated on map loading and search for user position.
Once user location is founded, the map will automatically centered in using user coordinates.
**kwargs
For possible options, see https://github.com/domoritz/leaflet-locatecontrol
Examples
--------
>>> m = folium.Map()
# With default settings
>>> LocateControl().add_to(m)
# With some custom options
>>> LocateControl(
... position="bottomright",
... strings={"title": "See you current location",
... "popup": "Your position"}).add_to(m))
For more info check:
https://github.com/domoritz/leaflet-locatecontrol
"""
_template = Template("""
{% macro script(this, kwargs) %}
var {{this.get_name()}} = L.control.locate(
{{this.options | tojson}}
).addTo({{this._parent.get_name()}});
{% if this.auto_start %}
{{this.get_name()}}.start();
{% endif %}
{% endmacro %}
""")
default_js = [
('Control_locate_min_js',
'https://cdnjs.cloudflare.com/ajax/libs/leaflet-locatecontrol/0.66.2/L.Control.Locate.min.js')
]
default_css = [
('Control_locate_min_css',
'https://cdnjs.cloudflare.com/ajax/libs/leaflet-locatecontrol/0.66.2/L.Control.Locate.min.css')
]
def __init__(self, auto_start=False, **kwargs):
super(LocateControl, self).__init__()
self._name = 'LocateControl'
self.auto_start = auto_start
self.options = parse_options(**kwargs)
| {
"repo_name": "python-visualization/folium",
"path": "folium/plugins/locate_control.py",
"copies": "2",
"size": "2302",
"license": "mit",
"hash": -5430750179169502000,
"line_mean": 30.9722222222,
"line_max": 104,
"alpha_frac": 0.6242397915,
"autogenerated": false,
"ratio": 3.8559463986599667,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 1,
"avg_score": 0.0010168573215186723,
"num_lines": 72
} |
"""Add location attributes to Request.
Revision ID: 2f22504b1e6
Revises: None
Create Date: 2014-05-02 13:24:00.045482
"""
# revision identifiers, used by Alembic.
revision = '2f22504b1e6'
down_revision = None
from alembic import op
import sqlalchemy as sa
from sqlalchemy.sql import update, select, table, column
import requests
from time import sleep
from evesrp import systems
session = requests.Session()
def get_system_id(kill_id):
# Have to put a sleep in here to prevent hammering the server and getting
# banned
sleep(10)
resp = session.get(
'https://zkb.pleaseignore.com/api/no-attackers/no-items/killID/{}'
.format(kill_id))
if resp.status_code == 200:
return int(resp.json()[0]['solarSystemID'])
else:
print(resp.text)
return None
request = table('request',
column('id', sa.Integer),
column('system', sa.String(25)),
column('constellation', sa.String(25)),
column('region', sa.String(25)),
)
def upgrade():
# Add columns, but with null allowed
op.add_column('request', sa.Column('constellation', sa.String(length=25),
nullable=True))
op.add_column('request', sa.Column('region', sa.String(length=25),
nullable=True))
op.add_column('request', sa.Column('system', sa.String(length=25),
nullable=True))
op.create_index('ix_request_constellation', 'request', ['constellation'],
unique=False)
op.create_index('ix_request_region', 'request', ['region'], unique=False)
op.create_index('ix_request_system', 'request', ['system'], unique=False)
# Update existing requests
conn = op.get_bind()
kill_id_sel = select([request.c.id])
kill_ids = conn.execute(kill_id_sel)
for kill_id in kill_ids:
kill_id = kill_id[0]
system_id = get_system_id(kill_id)
system = systems.system_names[system_id]
constellation = systems.systems_constellations[system]
region = systems.constellations_regions[constellation]
update_stmt = update(request)\
.where(request.c.id==op.inline_literal(kill_id))\
.values({
'system': system,
'constellation': constellation,
'region': region,
})
conn.execute(update_stmt)
kill_ids.close()
# Add non-null constraint
op.alter_column('request', 'constellation', nullable=False,
existing_server_default=None,
existing_type=sa.String(length=25))
op.alter_column('request', 'region', nullable=False,
existing_server_default=None,
existing_type=sa.String(length=25))
op.alter_column('request', 'system', nullable=False,
existing_server_default=None,
existing_type=sa.String(length=25))
def downgrade():
op.drop_index('ix_request_system', table_name='request')
op.drop_index('ix_request_region', table_name='request')
op.drop_index('ix_request_constellation', table_name='request')
op.drop_column('request', 'system')
op.drop_column('request', 'region')
op.drop_column('request', 'constellation')
| {
"repo_name": "paxswill/evesrp",
"path": "src/evesrp/migrate/versions/2f22504b1e6_.py",
"copies": "1",
"size": "3200",
"license": "bsd-2-clause",
"hash": 4879872680741604000,
"line_mean": 32.3333333333,
"line_max": 78,
"alpha_frac": 0.6303125,
"autogenerated": false,
"ratio": 3.5754189944134076,
"config_test": false,
"has_no_keywords": false,
"few_assignments": false,
"quality_score": 0.47057314944134077,
"avg_score": null,
"num_lines": null
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.