Search is not available for this dataset
text stringlengths 75 104k |
|---|
def check_uniqueness_constraint(m, kind=None):
'''
Check the model for uniqueness constraint violations.
'''
if kind is None:
metaclasses = m.metaclasses.values()
else:
metaclasses = [m.find_metaclass(kind)]
res = 0
for metaclass in metaclasses:
id_map = dict()
for identifier in metaclass.indices:
id_map[identifier] = dict()
for inst in metaclass.select_many():
# Check for null-values
for name, ty in metaclass.attributes:
if name not in metaclass.identifying_attributes:
continue
value = getattr(inst, name)
isnull = value is None
isnull |= (ty == 'UNIQUE_ID' and not value)
if isnull:
res += 1
logger.warning('%s.%s is part of an identifier and is null'
% (metaclass.kind, name))
# Check uniqueness
for identifier in metaclass.indices:
kwargs = dict()
for name in metaclass.indices[identifier]:
kwargs[name] = getattr(inst, name)
index_key = frozenset(kwargs.items())
if index_key in id_map[identifier]:
res += 1
id_string = pretty_unique_identifier(inst, identifier)
logger.warning('uniqueness constraint violation in %s, %s'
% (metaclass.kind, id_string))
id_map[identifier][index_key] = inst
return res |
def check_link_integrity(m, link):
'''
Check the model for integrity violations on an association in a particular direction.
'''
res = 0
for inst in link.from_metaclass.select_many():
q_set = list(link.navigate(inst))
if(len(q_set) < 1 and not link.conditional) or (
(len(q_set) > 1 and not link.many)):
res += 1
logger.warning('integrity violation in '
'%s --(%s)--> %s' % (pretty_from_link(inst, link),
link.rel_id,
pretty_to_link(inst, link)))
return res |
def check_subtype_integrity(m, super_kind, rel_id):
'''
Check the model for integrity violations across a subtype association.
'''
if isinstance(rel_id, int):
rel_id = 'R%d' % rel_id
res = 0
for inst in m.select_many(super_kind):
if not xtuml.navigate_subtype(inst, rel_id):
res += 1
logger.warning('integrity violation across '
'%s[%s]' % (super_kind, rel_id))
return res |
def check_association_integrity(m, rel_id=None):
'''
Check the model for integrity violations on association(s).
'''
if isinstance(rel_id, int):
rel_id = 'R%d' % rel_id
res = 0
for ass in m.associations:
if rel_id in [ass.rel_id, None]:
res += check_link_integrity(m, ass.source_link)
res += check_link_integrity(m, ass.target_link)
return res |
def skip_module(*modules):
"""
This will exclude all of the "modules" from the traceback
:param modules: list of modules to exclude
:return: None
"""
modules = (modules and isinstance(modules[0], list)) and \
modules[0] or modules
for module in modules:
if not module in SKIPPED_MODULES:
SKIPPED_MODULES.append(module)
traceback.extract_tb = _new_extract_tb |
def only_module(*modules):
"""
This will exclude all modules from the traceback except these "modules"
:param modules: list of modules to report in traceback
:return: None
"""
modules = (modules and isinstance(modules[0], list)) and \
modules[0] or modules
for module in modules:
if not module in ONLY_MODULES:
ONLY_MODULES.append(module)
traceback.extract_tb = _new_extract_tb |
def skip_path(*paths):
"""
This will exclude all modules that start from this path
:param paths: list of str of the path of modules to exclude
:return: None
"""
paths = (paths and isinstance(paths[0], list)) and paths[0] or paths
for path in paths:
if not path in SKIPPED_PATHS:
SKIPPED_PATHS.append(path)
traceback.extract_tb = _new_extract_tb |
def feature_index(*feature_names):
'''Returns a index creation function.
Returns a valid index ``create`` function for the feature names
given. This can be used with the :meth:`Store.define_index`
method to create indexes on any combination of features in a
feature collection.
:type feature_names: list(unicode)
:rtype: ``(val -> index val)
-> (content_id, FeatureCollection)
-> generator of [index val]``
'''
def _(trans, (cid, fc)):
for fname in feature_names:
feat = fc.get(fname)
if feat is None:
continue
elif isinstance(feat, unicode):
yield trans(feat)
else: # string counter, sparse/dense vector
for val in feat.iterkeys():
yield trans(val)
return _ |
def basic_transform(val):
'''A basic transform for strings and integers.'''
if isinstance(val, int):
return struct.pack('>i', val)
else:
return safe_lower_utf8(val) |
def safe_lower_utf8(x):
'''x.lower().encode('utf-8') where x can be None, str, or unicode'''
if x is None:
return None
x = x.lower()
if isinstance(x, unicode):
return x.encode('utf-8')
return x |
def get(self, content_id):
'''Retrieve a feature collection from the store. This is the same as
get_many([content_id])
If the feature collection does not exist ``None`` is
returned.
:type content_id: str
:rtype: :class:`dossier.fc.FeatureCollection`
'''
rows = list(self.kvl.get(self.TABLE, (content_id,)))
assert len(rows) < 2, 'more than one FC with the same content id'
if len(rows) == 0 or rows[0][1] is None:
return None
return fc_loads(rows[0][1]) |
def get_many(self, content_id_list):
'''Yield (content_id, data) tuples for ids in list.
As with :meth:`get`, if a content_id in the list is missing,
then it is yielded with a data value of `None`.
:type content_id_list: list<str>
:rtype: yields tuple(str, :class:`dossier.fc.FeatureCollection`)
'''
content_id_keys = [tuplify(x) for x in content_id_list]
for row in self.kvl.get(self.TABLE, *content_id_keys):
content_id = row[0][0]
data = row[1]
if data is not None:
data = fc_loads(data)
yield (content_id, data) |
def put(self, items, indexes=True):
'''Add feature collections to the store.
Given an iterable of tuples of the form
``(content_id, feature collection)``, add each to the store
and overwrite any that already exist.
This method optionally accepts a keyword argument `indexes`,
which by default is set to ``True``. When it is ``True``,
it will *create* new indexes for each content object for all
indexes defined on this store.
Note that this will not update existing indexes. (There is
currently no way to do this without running some sort of
garbage collection process.)
:param iterable items: iterable of
``(content_id, FeatureCollection)``.
:type fc: :class:`dossier.fc.FeatureCollection`
'''
# So why accept an iterable? Ideally, some day, `kvlayer.put` would
# accept an iterable, so we should too.
#
# But we have to transform it to a list in order to update indexes
# anyway. Well, if we don't have to update indexes, then we can avoid
# loading everything into memory, which seems like an optimization
# worth having even if it's only some of the time.
#
# N.B. If you're thinking, "Just use itertools.tee", then you should
# heed this warning from Python docs: "This itertool may require
# significant auxiliary storage (depending on how much temporary data
# needs to be stored). In general, if one iterator uses most or all of
# the data before another iterator starts, it is faster to use list()
# instead of tee()."
#
# i.e., `tee` has to store everything into memory because `kvlayer`
# will exhaust the first iterator before indexes get updated.
items = list(items)
self.kvl.put(self.TABLE,
*imap(lambda (cid, fc): ((cid,), fc_dumps(fc)), items))
if indexes:
for idx_name in self._indexes:
self._index_put(idx_name, *items) |
def delete_all(self):
'''Deletes all storage.
This includes every content object and all index data.
'''
self.kvl.clear_table(self.TABLE)
self.kvl.clear_table(self.INDEX_TABLE) |
def scan(self, *key_ranges):
'''Retrieve feature collections in a range of ids.
Returns a generator of content objects corresponding to the
content identifier ranges given. `key_ranges` can be a possibly
empty list of 2-tuples, where the first element of the tuple
is the beginning of a range and the second element is the end
of a range. To specify the beginning or end of the table, use
an empty tuple `()`.
If the list is empty, then this yields all content objects in
the storage.
:param key_ranges: as described in
:meth:`kvlayer._abstract_storage.AbstractStorage`
:rtype: generator of
(``content_id``, :class:`dossier.fc.FeatureCollection`).
'''
# (id, id) -> ((id,), (id,))
key_ranges = [(tuplify(s), tuplify(e)) for s, e in key_ranges]
return imap(lambda (cid, fc): (cid[0], fc_loads(fc)),
self.kvl.scan(self.TABLE, *key_ranges)) |
def scan_ids(self, *key_ranges):
'''Retrieve content ids in a range of ids.
Returns a generator of ``content_id`` corresponding to the
content identifier ranges given. `key_ranges` can be a possibly
empty list of 2-tuples, where the first element of the tuple
is the beginning of a range and the second element is the end
of a range. To specify the beginning or end of the table, use
an empty tuple `()`.
If the list is empty, then this yields all content ids in
the storage.
:param key_ranges: as described in
:meth:`kvlayer._abstract_storage.AbstractStorage`
:rtype: generator of ``content_id``
'''
# (id, id) -> ((id,), (id,))
key_ranges = [(tuplify(s), tuplify(e)) for s, e in key_ranges]
scanner = self.kvl.scan_keys(self.TABLE, *key_ranges)
return imap(itemgetter(0), scanner) |
def index_scan(self, idx_name, val):
'''Returns ids that match an indexed value.
Returns a generator of content identifiers that have an entry
in the index ``idx_name`` with value ``val`` (after index
transforms are applied).
If the index named by ``idx_name`` is not registered, then a
:exc:`~exceptions.KeyError` is raised.
:param unicode idx_name: name of index
:param val: the value to use to search the index
:type val: unspecified (depends on the index, usually ``unicode``)
:rtype: generator of ``content_id``
:raises: :exc:`~exceptions.KeyError`
'''
idx = self._index(idx_name)['transform']
key = (idx(val), idx_name.encode('utf-8'))
keys = self.kvl.scan_keys(self.INDEX_TABLE, (key, key))
return imap(lambda k: k[2], keys) |
def index_scan_prefix(self, idx_name, val_prefix):
'''Returns ids that match a prefix of an indexed value.
Returns a generator of content identifiers that have an entry
in the index ``idx_name`` with prefix ``val_prefix`` (after
index transforms are applied).
If the index named by ``idx_name`` is not registered, then a
:exc:`~exceptions.KeyError` is raised.
:param unicode idx_name: name of index
:param val_prefix: the value to use to search the index
:type val: unspecified (depends on the index, usually ``unicode``)
:rtype: generator of ``content_id``
:raises: :exc:`~exceptions.KeyError`
'''
return self._index_scan_prefix_impl(
idx_name, val_prefix, lambda k: k[2]) |
def index_scan_prefix_and_return_key(self, idx_name, val_prefix):
'''Returns ids that match a prefix of an indexed value, and the
specific key that matched the search prefix.
Returns a generator of (index key, content identifier) that
have an entry in the index ``idx_name`` with prefix
``val_prefix`` (after index transforms are applied).
If the index named by ``idx_name`` is not registered, then a
:exc:`~exceptions.KeyError` is raised.
:param unicode idx_name: name of index
:param val_prefix: the value to use to search the index
:type val: unspecified (depends on the index, usually ``unicode``)
:rtype: generator of (``index key``, ``content_id``)
:raises: :exc:`~exceptions.KeyError`
'''
return self._index_scan_prefix_impl(
idx_name, val_prefix, lambda k: (k[0], k[2])) |
def _index_scan_prefix_impl(self, idx_name, val_prefix, retfunc):
'''Implementation for index_scan_prefix and
index_scan_prefix_and_return_key, parameterized on return
value function.
retfunc gets passed a key tuple from the index:
(index name, index value, content_id)
'''
idx = self._index(idx_name)['transform']
val_prefix = idx(val_prefix)
idx_name = idx_name.encode('utf-8')
s = (val_prefix, idx_name)
e = (val_prefix + '\xff', idx_name)
keys = self.kvl.scan_keys(self.INDEX_TABLE, (s, e))
return imap(retfunc, keys) |
def define_index(self, idx_name, create, transform):
'''Add an index to this store instance.
Adds an index transform to the current FC store. Once an index
with name ``idx_name`` is added, it will be available in all
``index_*`` methods. Additionally, the index will be automatically
updated on calls to :meth:`~dossier.fc.store.Store.put`.
If an index with name ``idx_name`` already exists, then it is
overwritten.
Note that indexes do *not* persist. They must be re-defined for
each instance of :class:`Store`.
For example, to add an index on the ``boNAME`` feature, you can
use the ``feature_index`` helper function:
.. code-block:: python
store.define_index('boNAME',
feature_index('boNAME'),
lambda s: s.encode('utf-8'))
Another example for creating an index on names:
.. code-block:: python
store.define_index('NAME',
feature_index('canonical_name', 'NAME'),
lambda s: s.lower().encode('utf-8'))
:param idx_name: The name of the index. Must be UTF-8 encodable.
:type idx_name: unicode
:param create: A function that accepts the ``transform`` function and
a pair of ``(content_id, fc)`` and produces a generator
of index values from the pair given using ``transform``.
:param transform: A function that accepts an arbitrary value and
applies a transform to it. This transforms the
*stored* value to the *index* value. This *must*
produce a value with type `str` (or `bytes`).
'''
assert isinstance(idx_name, (str, unicode))
idx_name = idx_name.decode('utf-8')
self._indexes[idx_name] = {'create': create, 'transform': transform} |
def _index_put(self, idx_name, *ids_and_fcs):
'''Add new index values.
Adds new index values for index ``idx_name`` for the pairs
given. Each pair should be a content identifier and a
:class:`dossier.fc.FeatureCollection`.
:type idx_name: unicode
:type ids_and_fcs: ``[(content_id, FeatureCollection)]``
'''
keys = self._index_keys_for(idx_name, *ids_and_fcs)
with_vals = map(lambda k: (k, '0'), keys)
# TODO: use imap when kvl.put takes an iterable
self.kvl.put(self.INDEX_TABLE, *with_vals) |
def _index_put_raw(self, idx_name, content_id, val):
'''Add new raw index values.
Adds a new index key corresponding to
``(idx_name, transform(val), content_id)``.
This method bypasses the *creation* of indexes from content
objects, but values are still transformed.
:type idx_name: unicode
:type content_id: str
:type val: unspecified (depends on the index, usually ``unicode``)
'''
idx = self._index(idx_name)['transform']
key = (idx(val), idx_name.encode('utf-8'), content_id)
self.kvl.put(self.INDEX_TABLE, (key, '0')) |
def _index_keys_for(self, idx_name, *ids_and_fcs):
'''Returns a generator of index triples.
Returns a generator of index keys for the ``ids_and_fcs`` pairs
given. The index keys have the form ``(idx_name, idx_val,
content_id)``.
:type idx_name: unicode
:type ids_and_fcs: ``[(content_id, FeatureCollection)]``
:rtype: generator of ``(str, str, str)``
'''
idx = self._index(idx_name)
icreate, itrans = idx['create'], idx['transform']
if isinstance(idx_name, unicode):
idx_name = idx_name.encode('utf-8')
for cid_fc in ids_and_fcs:
content_id = cid_fc[0]
# Be sure to dedup index_values or else we may
# suffer duplicate_pkey errors down the line.
seen_values = set()
for index_value in icreate(itrans, cid_fc):
if index_value and index_value not in seen_values:
yield (index_value, idx_name, content_id)
seen_values.add(index_value) |
def _index(self, name):
'''Returns index transforms for ``name``.
:type name: unicode
:rtype: ``{ create |--> function, transform |--> function }``
'''
name = name.decode('utf-8')
try:
return self._indexes[name]
except KeyError:
raise KeyError('Index "%s" has not been registered with '
'this FC store.' % name) |
async def fetch_twitter(handle: str) -> List:
"""
Gets the twitter feed for a given handle.
:param handle: The twitter handle.
:return: A list of entries in a user's feed.
:raises ApiError: When the api couldn't connect.
:raises CircuitBreakerError: When the circuit breaker is open.
"""
async with ClientSession() as session:
try:
async with session.get(f"http://twitrss.me/twitter_user_to_rss/?user={handle}") as request:
text = await request.text()
except ClientConnectionError as con_err:
logger.debug(f"Could not connect to {con_err.host}")
raise ApiError(f"Could not connect to {con_err.host}")
else:
feed = parse(text)
for x in feed.entries:
x["image"] = feed.feed["image"]["href"]
return feed.entries |
async def fetch_nearby(lat: float, long: float, limit: int = 10) -> Optional[List[Dict]]:
"""
Gets wikipedia articles near a given set of coordinates.
:raise ApiError: When there was an error connecting to the API.
todo cache
"""
request_url = f"https://en.wikipedia.org/w/api.php?action=query" \
f"&list=geosearch" \
f"&gscoord={lat}%7C{long}" \
f"&gsradius=10000" \
f"&gslimit={limit}" \
f"&format=json"
async with ClientSession() as session:
try:
async with session.get(request_url) as request:
if request.status == 404:
return None
data = (await request.json())["query"]["geosearch"]
except ClientConnectionError as con_err:
logger.debug(f"Could not connect to {con_err.host}")
raise ApiError(f"Could not connect to {con_err.host}")
except JSONDecodeError as dec_err:
logger.error(f"Could not decode data: {dec_err}")
raise ApiError(f"Could not decode data: {dec_err}")
except KeyError:
return None
else:
for location in data:
location.pop("ns")
location.pop("primary")
return data |
def execute_get_text(command): # type: (str) ->str
"""
Execute shell command and return stdout txt
:param command:
:return:
"""
try:
completed = subprocess.run(
command,
check=True,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
except subprocess.CalledProcessError as err:
raise
else:
print(completed.stdout.decode('utf-8') + str(":") + completed.stderr.decode("utf-8"))
return completed.stdout.decode('utf-8') + completed.stderr.decode("utf-8") |
def has_source_code_tree_changed(self):
"""
If a task succeeds & is re-run and didn't change, we might not
want to re-run it if it depends *only* on source code
:return:
"""
global CURRENT_HASH
directory = self.where
# if CURRENT_HASH is None:
# print("hashing " + directory)
# print(os.listdir(directory))
CURRENT_HASH = dirhash(directory, 'md5', ignore_hidden=True,
# changing these exclusions can cause dirhas to skip EVERYTHING
excluded_files=[".coverage", "lint.txt"],
excluded_extensions=[".pyc"]
)
print("Searching " + self.state_file_name)
if os.path.isfile(self.state_file_name):
with open(self.state_file_name, "r+") as file:
last_hash = file.read()
if last_hash != CURRENT_HASH:
file.seek(0)
file.write(CURRENT_HASH)
file.truncate()
return True
else:
return False
# no previous file, by definition not the same.
with open(self.state_file_name, "w") as file:
file.write(CURRENT_HASH)
return True |
def check_pypi_name(pypi_package_name, pypi_registry_host=None):
"""
Check if a package name exists on pypi.
TODO: Document the Registry URL construction.
It may not be obvious how pypi_package_name and pypi_registry_host are used
I'm appending the simple HTTP API parts of the registry standard specification.
It will return True if the package name, or any equivalent variation as defined by PEP 503 normalisation
rules (https://www.python.org/dev/peps/pep-0503/#normalized-names) is registered in the PyPI registry.
>>> check_pypi_name('pip')
True
>>> check_pypi_name('Pip')
True
It will return False if the package name, or any equivalent variation as defined by PEP 503 normalisation
rules (https://www.python.org/dev/peps/pep-0503/#normalized-names) is not registered in the PyPI registry.
>>> check_pypi_name('testy_mc-test_case-has.a.cousin_who_should_never_write_a_package')
False
:param pypi_package_name:
:param pypi_registry_host:
:return:
"""
if pypi_registry_host is None:
pypi_registry_host = 'pypi.python.org'
# Just a helpful reminder why this bytearray size was chosen.
# HTTP/1.1 200 OK
# HTTP/1.1 404 Not Found
receive_buffer = bytearray(b'------------')
context = ssl.create_default_context()
ssl_http_socket = context.wrap_socket(socket.socket(socket.AF_INET), server_hostname=pypi_registry_host)
ssl_http_socket.connect((pypi_registry_host, 443))
ssl_http_socket.send(b''.join([
b"HEAD /simple/", pypi_package_name.encode('ascii'), b"/ HTTP/1.0", b"\r\n",
b"Host: ", pypi_registry_host.encode('ascii'), b"\r\n",
b"\r\n\r\n"
]))
ssl_http_socket.recv_into(receive_buffer)
# Early return when possible.
if b'HTTP/1.1 200' in receive_buffer:
ssl_http_socket.shutdown(1)
ssl_http_socket.close()
return True
elif b'HTTP/1.1 404' in receive_buffer:
ssl_http_socket.shutdown(1)
ssl_http_socket.close()
return False
remaining_bytes = ssl_http_socket.recv(2048)
redirect_path_location_start = remaining_bytes.find(b'Location:') + 10
redirect_path_location_end = remaining_bytes.find(b'\r\n', redirect_path_location_start)
# Append the trailing slash to avoid a needless extra redirect.
redirect_path = remaining_bytes[redirect_path_location_start:redirect_path_location_end] + b'/'
ssl_http_socket.shutdown(1)
ssl_http_socket.close()
# Reset the bytearray to empty
# receive_buffer = bytearray(b'------------')
ssl_http_socket = context.wrap_socket(socket.socket(socket.AF_INET), server_hostname=pypi_registry_host)
ssl_http_socket.connect((pypi_registry_host, 443))
ssl_http_socket.send(b''.join([
b"HEAD ", redirect_path, b" HTTP/1.0", b"\r\n",
b"Host: ", pypi_registry_host.encode('ascii'), b"\r\n",
b"\r\n\r\n"]))
ssl_http_socket.recv_into(receive_buffer)
if b'HTTP/1.1 200' in receive_buffer:
return True
elif b'HTTP/1.1 404' in receive_buffer:
return False
else:
NotImplementedError('A definitive answer was not found by primary or secondary lookups.') |
def add_direction(value, arg=u"rtl_only"):
"""Adds direction to the element
:arguments:
arg
* rtl_only: Add the direction only in case of a
right-to-left language (default)
* both: add the direction in both case
* ltr_only: Add the direction only in case of a
left-to-right language
{{image_name|add_direction}} when image_name is 'start_arrow.png'
results in 'start_arrow_rtl.png' in case of RTL language, and
'start_arrow.png' or 'start_arrow_ltr.png' depends on `arg` value.
"""
if arg == u'rtl_only':
directions = (u'', u'_rtl')
elif arg == u'both':
directions = (u'_ltr', u'_rtl')
elif arg == u'ltr_only':
directions = (u'_ltr', u'')
else:
raise template.TemplateSyntaxError('add_direction can use arg with one of ["rtl_only", "both", "ltr_only"]')
parts = value.rsplit('.', 1)
if not len(parts):
return value
elif len(parts) == 1:
return value + directions[translation.get_language_bidi()]
else:
return '.'.join((parts[0]+directions[translation.get_language_bidi()],parts[1])) |
async def fetch_postcodes_from_coordinates(lat: float, long: float) -> Optional[List[Postcode]]:
"""
Gets a postcode object from the lat and long.
:param lat: The latitude to look up.
:param long: The longitude to look up.
:return: The mapping corresponding to the lat and long or none if the postcode does not exist.
:raises ApiError: When there was an error connecting to the API.
:raises CircuitBreakerError: When the circuit breaker is open.
"""
postcode_lookup = f"/postcodes?lat={lat}&lon={long}"
return await _get_postcode_from_url(postcode_lookup) |
def get_type_name(s_dt):
'''
get the xsd name of a S_DT
'''
s_cdt = nav_one(s_dt).S_CDT[17]()
if s_cdt and s_cdt.Core_Typ in range(1, 6):
return s_dt.Name
s_edt = nav_one(s_dt).S_EDT[17]()
if s_edt:
return s_dt.Name
s_udt = nav_one(s_dt).S_UDT[17]()
if s_udt:
return s_dt.Name |
def get_refered_attribute(o_attr):
'''
Get the the referred attribute.
'''
o_attr_ref = nav_one(o_attr).O_RATTR[106].O_BATTR[113].O_ATTR[106]()
if o_attr_ref:
return get_refered_attribute(o_attr_ref)
else:
return o_attr |
def build_core_type(s_cdt):
'''
Build an xsd simpleType out of a S_CDT.
'''
s_dt = nav_one(s_cdt).S_DT[17]()
if s_dt.name == 'void':
type_name = None
elif s_dt.name == 'boolean':
type_name = 'xs:boolean'
elif s_dt.name == 'integer':
type_name = 'xs:integer'
elif s_dt.name == 'real':
type_name = 'xs:decimal'
elif s_dt.name == 'string':
type_name = 'xs:string'
elif s_dt.name == 'unique_id':
type_name = 'xs:integer'
else:
type_name = None
if type_name:
mapped_type = ET.Element('xs:simpleType', name=s_dt.name)
ET.SubElement(mapped_type, 'xs:restriction', base=type_name)
return mapped_type |
def build_enum_type(s_edt):
'''
Build an xsd simpleType out of a S_EDT.
'''
s_dt = nav_one(s_edt).S_DT[17]()
enum = ET.Element('xs:simpleType', name=s_dt.name)
enum_list = ET.SubElement(enum, 'xs:restriction', base='xs:string')
first_filter = lambda selected: not nav_one(selected).S_ENUM[56, 'succeeds']()
s_enum = nav_any(s_edt).S_ENUM[27](first_filter)
while s_enum:
ET.SubElement(enum_list, 'xs:enumeration', value=s_enum.name)
s_enum = nav_one(s_enum).S_ENUM[56, 'precedes']()
return enum |
def build_struct_type(s_sdt):
'''
Build an xsd complexType out of a S_SDT.
'''
s_dt = nav_one(s_sdt).S_DT[17]()
struct = ET.Element('xs:complexType', name=s_dt.name)
first_filter = lambda selected: not nav_one(selected).S_MBR[46, 'succeeds']()
s_mbr = nav_any(s_sdt).S_MBR[44](first_filter)
while s_mbr:
s_dt = nav_one(s_mbr).S_DT[45]()
type_name = get_type_name(s_dt)
ET.SubElement(struct, 'xs:attribute', name=s_mbr.name, type=type_name)
s_mbr = nav_one(s_mbr).S_MBR[46, 'precedes']()
return struct |
def build_user_type(s_udt):
'''
Build an xsd simpleType out of a S_UDT.
'''
s_dt_user = nav_one(s_udt).S_DT[17]()
s_dt_base = nav_one(s_udt).S_DT[18]()
base_name = get_type_name(s_dt_base)
if base_name:
user = ET.Element('xs:simpleType', name=s_dt_user.name)
ET.SubElement(user, 'xs:restriction', base=base_name)
return user |
def build_type(s_dt):
'''
Build a partial xsd tree out of a S_DT and its sub types S_CDT, S_EDT, S_SDT and S_UDT.
'''
s_cdt = nav_one(s_dt).S_CDT[17]()
if s_cdt:
return build_core_type(s_cdt)
s_edt = nav_one(s_dt).S_EDT[17]()
if s_edt:
return build_enum_type(s_edt)
s_udt = nav_one(s_dt).S_UDT[17]()
if s_udt:
return build_user_type(s_udt) |
def build_class(o_obj):
'''
Build an xsd complex element out of a O_OBJ, including its O_ATTR.
'''
cls = ET.Element('xs:element', name=o_obj.key_lett, minOccurs='0', maxOccurs='unbounded')
attributes = ET.SubElement(cls, 'xs:complexType')
for o_attr in nav_many(o_obj).O_ATTR[102]():
o_attr_ref = get_refered_attribute(o_attr)
s_dt = nav_one(o_attr_ref).S_DT[114]()
while nav_one(s_dt).S_UDT[17]():
s_dt = nav_one(s_dt).S_UDT[17].S_DT[18]()
type_name = get_type_name(s_dt)
if type_name and not nav_one(o_attr).O_BATTR[106].O_DBATTR[107]():
ET.SubElement(attributes, 'xs:attribute', name=o_attr.name, type=type_name)
else:
logger.warning('Omitting %s.%s' % (o_obj.key_lett, o_attr.Name))
return cls |
def build_component(m, c_c):
'''
Build an xsd complex element out of a C_C, including its packaged S_DT and O_OBJ.
'''
component = ET.Element('xs:element', name=c_c.name)
classes = ET.SubElement(component, 'xs:complexType')
classes = ET.SubElement(classes, 'xs:sequence')
scope_filter = lambda selected: ooaofooa.is_contained_in(selected, c_c)
for o_obj in m.select_many('O_OBJ', scope_filter):
cls = build_class(o_obj)
classes.append(cls)
return component |
def build_schema(m, c_c):
'''
Build an xsd schema from a bridgepoint component.
'''
schema = ET.Element('xs:schema')
schema.set('xmlns:xs', 'http://www.w3.org/2001/XMLSchema')
global_filter = lambda selected: ooaofooa.is_global(selected)
for s_dt in m.select_many('S_DT', global_filter):
datatype = build_type(s_dt)
if datatype is not None:
schema.append(datatype)
scope_filter = lambda selected: ooaofooa.is_contained_in(selected, c_c)
for s_dt in m.select_many('S_DT', scope_filter):
datatype = build_type(s_dt)
if datatype is not None:
schema.append(datatype)
component = build_component(m, c_c)
schema.append(component)
return schema |
def prettify(xml_string):
'''
Indent an xml string with four spaces, and add an additional line break after each node.
'''
reparsed = xml.dom.minidom.parseString(xml_string)
return reparsed.toprettyxml(indent=" ") |
async def fetch_bikes() -> List[dict]:
"""
Gets the full list of bikes from the bikeregister site.
The data is hidden behind a form post request and so
we need to extract an xsrf and session token with bs4.
todo add pytest tests
:return: All the currently registered bikes.
:raise ApiError: When there was an error connecting to the API.
"""
async with ClientSession() as session:
try:
async with session.get('https://www.bikeregister.com/stolen-bikes') as request:
document = document_fromstring(await request.text())
except ClientConnectionError as con_err:
logger.debug(f"Could not connect to {con_err.host}")
raise ApiError(f"Could not connect to {con_err.host}")
token = document.xpath("//input[@name='_token']")
if len(token) != 1:
raise ApiError(f"Couldn't extract token from page.")
else:
token = token[0].value
xsrf_token = request.cookies["XSRF-TOKEN"]
laravel_session = request.cookies["laravel_session"]
# get the bike data
headers = {
'cookie': f'XSRF-TOKEN={xsrf_token}; laravel_session={laravel_session}',
'origin': 'https://www.bikeregister.com',
'accept-encoding': 'gzip, deflate, br',
'accept-language': 'en-GB,en-US;q=0.9,en;q=0.8',
'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0',
'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
'accept': '*/*',
'referer': 'https://www.bikeregister.com/stolen-bikes',
'authority': 'www.bikeregister.com',
'x-requested-with': 'XMLHttpRequest',
}
data = [
('_token', token),
('make', ''),
('model', ''),
('colour', ''),
('reporting_period', '1'),
]
try:
async with session.post('https://www.bikeregister.com/stolen-bikes', headers=headers, data=data) as request:
bikes = json.loads(await request.text())
except ClientConnectionError as con_err:
logger.debug(f"Could not connect to {con_err.host}")
raise ApiError(f"Could not connect to {con_err.host}")
except json.JSONDecodeError as dec_err:
logger.error(f"Could not decode data: {dec_err.msg}")
raise ApiError(f"Could not decode data: {dec_err.msg}")
return bikes
# if cant open a session
return [] |
def set_positional_info(node, p):
'''
set positional information on a node
'''
node.position = Position()
node.position.label = p.lexer.label
node.position.start_stream = p.lexpos(1)
node.position.start_line = p.lineno(1)
node.position.start_column = find_column(p.lexer.lexdata,
node.position.start_stream)
_, node.position.end_stream = p.lexspan(len(p) - 1)
_, node.position.end_line = p.linespan(len(p) - 1)
node.position.end_column = find_column(p.lexer.lexdata,
node.position.end_stream) - 1
node.character_stream = p.lexer.lexdata[node.position.start_stream:
node.position.end_stream] |
def track_production(f):
'''
decorator for adding positional information to returning nodes
'''
@wraps(f)
def wrapper(self, p):
r = f(self, p)
node = p[0]
if isinstance(node, Node) and len(p) > 1:
set_positional_info(node, p)
return r
return wrapper |
def t_SL_STRING(self, t):
r'\/\/.*\n'
t.lexer.lineno += t.value.count('\n')
t.endlexpos = t.lexpos + len(t.value) |
def t_TICKED_PHRASE(self, t):
r"\'[^\']*\'"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_STRING(self, t):
r'"[^"\n]*"'
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_END_FOR(self, t):
r"(?i)end[\s]+for"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_END_IF(self, t):
r"(?i)end[\s]+if"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_END_WHILE(self, t):
r"(?i)end[\s]+while"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_NAMESPACE(self, t):
r"([0-9a-zA-Z_])+(?=::)"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_ID(self, t):
r"[a-zA-Z_][0-9a-zA-Z_]*|[a-zA-Z][0-9a-zA-Z_]*[0-9a-zA-Z_]+"
t.endlexpos = t.lexpos + len(t.value)
value = t.value.upper()
if value in self.keywords:
t.type = value
return t |
def t_DOUBLECOLON(self, t):
r"::"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_DOUBLEEQUAL(self, t):
r"\=\="
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_NOTEQUAL(self, t):
r"!\="
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_ARROW(self, t):
r"\-\>"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_LE(self, t):
r"\<\="
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_GE(self, t):
r"\>\="
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_EQUAL(self, t):
r"\="
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_DOT(self, t):
r"\."
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_TIMES(self, t):
r"\*"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_COLON(self, t):
r":"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_LSQBR(self, t):
r"\["
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_RSQBR(self, t):
r"\]"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_QMARK(self, t):
r"\?"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_LESSTHAN(self, t):
r"\<"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_GT(self, t):
r"\>"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_PLUS(self, t):
r"\+"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_DIV(self, t):
r"/"
t.endlexpos = t.lexpos + len(t.value)
return t |
def t_MOD(self, t):
r"%"
t.endlexpos = t.lexpos + len(t.value)
return t |
def p_statement_list_1(self, p):
'''statement_list : statement SEMICOLON statement_list'''
p[0] = p[3]
if p[1] is not None:
p[0].children.insert(0, p[1]) |
def p_statement_list_2(self, p):
'''statement_list : statement SEMICOLON'''
p[0] = StatementListNode()
if p[1] is not None:
p[0].children.insert(0, p[1]) |
def p_bridge_assignment_statement(self, p):
'''statement : BRIDGE variable_access EQUAL implicit_invocation'''
p[4].__class__ = BridgeInvocationNode
p[0] = AssignmentNode(variable_access=p[2],
expression=p[4]) |
def p_class_invocation_assignment_statement(self, p):
'''statement : TRANSFORM variable_access EQUAL implicit_invocation'''
p[4].__class__ = ClassInvocationNode
p[0] = AssignmentNode(variable_access=p[2],
expression=p[4]) |
def p_port_invocation_assignment_statement(self, p):
'''statement : SEND variable_access EQUAL implicit_invocation'''
p[4].__class__ = PortInvocationNode
p[0] = AssignmentNode(variable_access=p[2],
expression=p[4]) |
def p_port_event_generation(self, p):
'''statement : SEND namespace DOUBLECOLON identifier LPAREN parameter_list RPAREN TO expression'''
p[0] = GeneratePortEventNode(port_name=p[2],
action_name=p[4],
parameter_list=p[6],
expression=p[9]) |
def p_create_class_event_statement(self, p):
'''statement : CREATE EVENT INSTANCE variable_name OF event_specification TO identifier CLASS'''
p[0] = CreateClassEventNode(variable_name=p[4],
event_specification=p[6],
key_letter=p[8]) |
def p_create_assigner_event_statement(self, p):
'''statement : CREATE EVENT INSTANCE variable_name OF event_specification TO identifier ASSIGNER'''
p[0] = CreateClassEventNode(variable_name=p[4],
event_specification=p[6],
key_letter=p[8]) |
def p_create_creator_event_statement(self, p):
'''statement : CREATE EVENT INSTANCE variable_name OF event_specification TO identifier CREATOR'''
p[0] = CreateCreatorEventNode(variable_name=p[4],
event_specification=p[6],
key_letter=p[8]) |
def p_create_instance_event_statement_1(self, p):
'''statement : CREATE EVENT INSTANCE variable_name OF event_specification TO variable_access'''
p[0] = CreateInstanceEventNode(variable_name=p[4],
event_specification=p[6],
to_variable_access=p[8]) |
def p_create_instance_event_statement_2(self, p):
'''statement : CREATE EVENT INSTANCE variable_name OF event_specification TO self_access'''
p[0] = CreateInstanceEventNode(variable_name=p[4],
event_specification=p[6],
to_variable_access=p[8]) |
def p_event_specification(self, p):
'''event_specification : identifier event_meaning event_data'''
p[0] = EventSpecNode(identifier=p[1],
meaning=p[2],
event_data=p[3]) |
def p_ploymorphic_event_spec(self, p):
'''event_specification : identifier TIMES event_meaning event_data'''
p[0] = EventSpecNode(identifier=p[1],
meaning=p[3],
event_data=p[4]) |
def p_for_statement(self, p):
'''statement : FOR EACH variable_name IN variable_name block END_FOR'''
p[0] = ForEachNode(instance_variable_name=p[3],
set_variable_name=p[5],
block=p[6]) |
def p_if_statement(self, p):
'''statement : IF expression block elif_list else_clause END_IF'''
p[0] = IfNode(expression=p[2],
block=p[3],
elif_list=p[4],
else_clause=p[5]) |
def p_relate_statement_1(self, p):
'''statement : RELATE instance_name TO instance_name ACROSS rel_id'''
p[0] = RelateNode(from_variable_name=p[2],
to_variable_name=p[4],
rel_id=p[6],
phrase=None) |
def p_relate_statement_2(self, p):
'''statement : RELATE instance_name TO instance_name ACROSS rel_id DOT phrase'''
p[0] = RelateNode(from_variable_name=p[2],
to_variable_name=p[4],
rel_id=p[6],
phrase=p[8]) |
def p_relate_using_statement_1(self, p):
'''statement : RELATE instance_name TO instance_name ACROSS rel_id USING instance_name'''
p[0] = RelateUsingNode(from_variable_name=p[2],
to_variable_name=p[4],
rel_id=p[6],
phrase=None,
using_variable_name=p[8]) |
def p_unrelate_statement_1(self, p):
'''statement : UNRELATE instance_name FROM instance_name ACROSS rel_id'''
p[0] = UnrelateNode(from_variable_name=p[2],
to_variable_name=p[4],
rel_id=p[6],
phrase=None) |
def p_unrelate_statement_2(self, p):
'''statement : UNRELATE instance_name FROM instance_name ACROSS rel_id DOT phrase'''
p[0] = UnrelateNode(from_variable_name=p[2],
to_variable_name=p[4],
rel_id=p[6],
phrase=p[8]) |
def p_unrelate_statement_using_1(self, p):
'''statement : UNRELATE instance_name FROM instance_name ACROSS rel_id USING instance_name'''
p[0] = UnrelateUsingNode(from_variable_name=p[2],
to_variable_name=p[4],
rel_id=p[6],
phrase=None,
using_variable_name=p[8]) |
def p_select_from_statement_1(self, p):
'''
statement : SELECT ANY variable_name FROM INSTANCES OF identifier
| SELECT MANY variable_name FROM INSTANCES OF identifier
'''
p[0] = SelectFromNode(cardinality=p[2],
variable_name=p[3],
key_letter=p[7]) |
def p_select_from_statement_2(self, p):
'''
statement : SELECT ANY variable_name FROM identifier
| SELECT MANY variable_name FROM identifier
'''
p[0] = SelectFromNode(cardinality=p[2],
variable_name=p[3],
key_letter=p[5]) |
def p_select_from_where_statement_1(self, p):
'''
statement : SELECT ANY variable_name FROM INSTANCES OF identifier WHERE expression
| SELECT MANY variable_name FROM INSTANCES OF identifier WHERE expression
'''
p[0] = SelectFromWhereNode(cardinality=p[2],
variable_name=p[3],
key_letter=p[7],
where_clause=p[9]) |
def p_select_from_where_statement_2(self, p):
'''
statement : SELECT ANY variable_name FROM identifier WHERE expression
| SELECT MANY variable_name FROM identifier WHERE expression
'''
p[0] = SelectFromWhereNode(cardinality=p[2],
variable_name=p[3],
key_letter=p[5],
where_clause=p[7]) |
def p_select_related_statement(self, p):
'''
statement : SELECT ONE variable_name RELATED BY navigation_hook navigation_chain
| SELECT ANY variable_name RELATED BY navigation_hook navigation_chain
| SELECT MANY variable_name RELATED BY navigation_hook navigation_chain
'''
p[0] = SelectRelatedNode(cardinality=p[2],
variable_name=p[3],
handle=p[6],
navigation_chain=p[7]) |
def p_select_related_where_statement(self, p):
'''
statement : SELECT ONE variable_name RELATED BY navigation_hook navigation_chain WHERE expression
| SELECT ANY variable_name RELATED BY navigation_hook navigation_chain WHERE expression
| SELECT MANY variable_name RELATED BY navigation_hook navigation_chain WHERE expression
'''
p[0] = SelectRelatedWhereNode(cardinality=p[2],
variable_name=p[3],
handle=p[6],
navigation_chain=p[7],
where_clause=p[9]) |
def p_navigation_step_1(self, p):
'''navigation_step : ARROW identifier LSQBR identifier RSQBR'''
p[0] = NavigationStepNode(key_letter=p[2],
rel_id=p[4],
phrase=None) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.