code
stringlengths 52
7.75k
| docs
stringlengths 1
5.85k
|
|---|---|
def modSymbolsFromLabelInfo(labelDescriptor):
modSymbols = set()
for labelStateEntry in viewvalues(labelDescriptor.labels):
for labelPositionEntry in viewvalues(labelStateEntry['aminoAcidLabels']):
for modSymbol in aux.toList(labelPositionEntry):
if modSymbol != '':
modSymbols.add(modSymbol)
return modSymbols
|
Returns a set of all modiciation symbols which were used in the
labelDescriptor
:param labelDescriptor: :class:`LabelDescriptor` describes the label setup
of an experiment
:returns: #TODO: docstring
|
def modAminoacidsFromLabelInfo(labelDescriptor):
modAminoacids = set()
for labelStateEntry in viewvalues(labelDescriptor.labels):
for labelPositionEntry in viewkeys(labelStateEntry['aminoAcidLabels']):
for modAminoacid in aux.toList(labelPositionEntry):
if modAminoacid != '':
modAminoacids.add(modAminoacid)
return modAminoacids
|
Returns a set of all amino acids and termini which can bear a label, as
described in "labelDescriptor".
:param labelDescriptor: :class:`LabelDescriptor` describes the label setup
of an experiment
:returns: #TODO: docstring
|
def addLabel(self, aminoAcidLabels, excludingModifications=None):
if excludingModifications is not None:
self.excludingModifictions = True
labelEntry = {'aminoAcidLabels': aminoAcidLabels,
'excludingModifications': excludingModifications
}
self.labels[self._labelCounter] = labelEntry
self._labelCounter += 1
|
Adds a new labelstate.
:param aminoAcidsLabels: Describes which amino acids can bear which
labels. Possible keys are the amino acids in one letter code and
'nTerm', 'cTerm'. Possible values are the modifications ids from
:attr:`maspy.constants.aaModMass` as strings or a list of strings.
An example for one expected label at the n-terminus and two expected
labels at each Lysine:
``{'nTerm': 'u:188', 'K': ['u:188', 'u:188']}``
:param excludingModifications: optional, A Dectionary that describes
which modifications can prevent the addition of labels. Keys and
values have to be the modifications ids from
:attr:`maspy.constants.aaModMass`. The key specifies the
modification that prevents the label modification specified by the
value. For example for each modification 'u:1' that is present at an
amino acid or terminus of a peptide the number of expected labels at
this position is reduced by one: ``{'u:1':'u:188'}``
|
def get_gen_slice(ctx=Bubble(), iterable=[], amount=-1, index=-1):
ctx.gbc.say('get_gen_slice', stuff=iterable, verbosity=10)
i = -1
# TODO
# i = 0 #NATURAL INDEX, this will break all features with exports and -p
if amount > 0:
if index < 0:
index = 0
else:
for item in iterable:
i += 1
item[buts('index')] = i
ctx.gbc.say('Get gen NO slice:item %d' % i, verbosity=100)
ctx.gbc.say('Get gen NO slice:a:%d i:%d' %
(amount, index), verbosity=100)
ctx.gbc.say('Get gen NO slice:item', stuff=item, verbosity=1000)
yield item
until = index + amount
if six.PY2:
sli = xrange(index, until)
else:
sli = range(index, until)
ctx.gbc.say('Get gen slice:range %s' % str(sli), verbosity=1000)
# TODO: iterable should be empty if not slicing
# if valid slice ...
for item in iterable:
i += 1
if i in sli:
ctx.gbc.say('Get gen slice:item %d' % i, verbosity=100)
ctx.gbc.say('Get gen slice:a:%d i:%d' %
(amount, index), verbosity=100)
ctx.gbc.say('Get gen slice:item', stuff=item, verbosity=1000)
item[buts('index')] = i
yield item
elif i > until:
break
else:
pass
|
very crude way of slicing a generator
|
def _get_scripts(self, scripts_path_rel, files_deployment, script_type, project_path):
scripts_dict = {}
if scripts_path_rel:
self._logger.debug('Getting scripts with {0} definitions'.format(script_type))
scripts_dict = pgpm.lib.utils.misc.collect_scripts_from_sources(scripts_path_rel, files_deployment,
project_path, False, self._logger)
if len(scripts_dict) == 0:
self._logger.debug('No {0} definitions were found in {1} folder'.format(script_type, scripts_path_rel))
else:
self._logger.debug('No {0} folder was specified'.format(script_type))
return scripts_dict
|
Gets scripts from specified folders
|
def _resolve_dependencies(self, cur, dependencies):
list_of_deps_ids = []
_list_of_deps_unresolved = []
_is_deps_resolved = True
for k, v in dependencies.items():
pgpm.lib.utils.db.SqlScriptsHelper.set_search_path(cur, self._pgpm_schema_name)
cur.execute("SELECT _find_schema('{0}', '{1}')"
.format(k, v))
pgpm_v_ext = tuple(cur.fetchone()[0][1:-1].split(','))
try:
list_of_deps_ids.append(int(pgpm_v_ext[0]))
except:
pass
if not pgpm_v_ext[0]:
_is_deps_resolved = False
_list_of_deps_unresolved.append("{0}: {1}".format(k, v))
return _is_deps_resolved, list_of_deps_ids, _list_of_deps_unresolved
|
Function checks if dependant packages are installed in DB
|
def find_table_links(self):
html = urlopen(self.model_url).read()
doc = lh.fromstring(html)
href_list = [area.attrib['href'] for area in doc.cssselect('map area')]
tables = self._inception_table_links(href_list)
return tables
|
When given a url, this function will find all the available table names
for that EPA dataset.
|
def _inception_table_links(self, href_list):
tables = set()
for link in href_list:
if not link.startswith('http://'):
link = self.agency_url + link
html = urlopen(link).read()
doc = lh.fromstring(html)
area = doc.cssselect('map area')
if area:
# Then this is a model containing models.
tables.update((a.attrib['href'] for a in area))
else:
# The link is a table without additional models.
tables.update(link)
return tables
|
Sometimes the EPA likes to nest their models and tables -- model within
a model within a model -- so this internal method tries to clear all
that up.
|
def find_definition_urls(self, set_of_links):
definition_dict = {}
re_link_name = re.compile('.*p_table_name=(\w+)&p_topic.*')
for link in set_of_links:
if link.startswith('http://'):
table_dict = {}
html = urlopen(link).read()
doc = lh.fromstring(html)
unordered_list = doc.cssselect('#main ul')[-1]
for li in unordered_list.iterchildren():
a = li.find('a')
table_dict.update({a.text: a.attrib['href']})
link_name = re_link_name.sub(r'\1', link).upper()
definition_dict.update({link_name: table_dict})
return definition_dict
|
Find the available definition URLs for the columns in a table.
|
def create_agency(self):
agency = self.agency
links = self.find_table_links()
definition_dict = self.find_definition_urls(links)
with open(agency + '.txt', 'w') as f:
f.write(str(definition_dict))
|
Create an agency text file of definitions.
|
def loop_through_agency(self):
agency = self.agency
with open(agency + '.txt') as f:
data = eval(f.read())
for table in data:
for column in data[table]:
value_link = data[table][column]
data[table][column] = self.grab_definition(value_link)
data = json.dumps(data)
with open(agency + '_values.json', 'w') as f:
f.write(str(data))
|
Loop through an agency to grab the definitions for its tables.
|
def grab_definition(self, url):
re_description = re.compile('Description:(.+?\\n)')
re_table_name = re.compile("(\w+ Table.+)")
if url.startswith('//'):
url = 'http:' + url
elif url.startswith('/'):
url = 'http://www.epa.gov' + url
try:
html = urlopen(url).read()
doc = lh.fromstring(html)
main = doc.cssselect('#main')[0]
text = main.text_content()
definition = re_description.search(text).group(1).strip()
except (AttributeError, IndexError, TypeError, HTTPError):
print url
else:
value = re_table_name.sub('', definition)
return value
return url
|
Grab the column definition of a table from the EPA using a combination
of regular expressions and lxml.
|
def add_arc(self, src, dst, char):
if src not in self.automaton.states():
self.add_state()
arc = fst.Arc(self.isyms[char], self.osyms[char], fst.Weight.One(self.automaton.weight_type()), dst)
self.automaton.add_arc(src, arc)
|
Adds a new Arc
Args:
src (int): The source state identifier
dst (int): The destination state identifier
char (str): The character for the transition
Returns:
None
|
def fixminimized(self, alphabet):
insymbols = fst.SymbolTable()
outsymbols = fst.SymbolTable()
num = 1
for char in self.alphabet:
self.isyms.__setitem__(char, num)
self.osyms.__setitem__(char, num)
insymbols.add_symbol(char, num)
outsymbols.add_symbol(char, num)
num = num + 1
self.automaton.set_input_symbols(insymbols)
self.automaton.set_output_symbols(outsymbols)
endstate = self.add_state()
for state in self.states:
for char in alphabet:
found = 0
for arc in state.arcs:
if self.isyms.find(arc.ilabel) == char:
found = 1
break
if found == 0:
self.add_arc(state.stateid, endstate, char)
self[endstate].final = False
for char in alphabet:
self.add_arc(endstate, endstate, char)
|
After pyfst minimization,
all unused arcs are removed,
and all sink states are removed.
However this may break compatibility.
Args:
alphabet (list): The input alphabet
Returns:
None
|
def complement(self, alphabet):
self._addsink(alphabet)
for state in self.automaton.states():
if self.automaton.final(state) == fst.Weight.One(self.automaton.weight_type()):
self.automaton.set_final(state, fst.Weight.Zero(self.automaton.weight_type()))
else:
self.automaton.set_final(state, fst.Weight.One(self.automaton.weight_type()))
|
Returns the complement of DFA
Args:
alphabet (list): The input alphabet
Returns:
None
|
def init_from_acceptor_bycopying(self, acceptor):
for state in acceptor.states:
for arc in state.arcs:
self.add_arc(state.stateid, arc.nextstate, acceptor.isyms.find(arc.ilabel))
if state.final:
print state.stateid,' is final'
self[state.stateid].final = True;
|
Adds a sink state
Args:
alphabet (list): The input alphabet
Returns:
None
|
def intersect(self, other):
self.automaton = fst.intersect(self.automaton, other.automaton)
return self
|
Constructs an unminimized DFA recognizing
the intersection of the languages of two given DFAs.
Args:
other (DFA): The other DFA that will be used
for the intersect operation
Returns:
Returns:
DFA: The resulting DFA
|
def main(*argv,
filesystem=None,
do_exit=True,
stdout=None,
stderr=None):
try:
mdcli = MdCLI()
mdcli.filesystem = filesystem
mdcli.stdout = stdout or sys.stdout
mdcli.stderr = stderr or sys.stderr
retval = mdcli.main(*argv, loop=LOOP_NEVER)
if do_exit:
sys.exit(retval)
else:
return retval
except KeyboardInterrupt:
pass
|
Main method for the cli.
We allow the filesystem to be overridden for test purposes.
|
def get_optparser(self):
p = Cmdln.get_optparser(self)
p.add_option(
"-M",
"--maildir",
action="store",
dest="maildir"
)
p.add_option(
"-V",
"--verbose",
action="store_true",
dest="verbose"
)
return p
|
Override to allow specification of the maildir
|
def do_lsfolders(self, subcmd, opts):
client = MdClient(self.maildir, filesystem=self.filesystem)
client.lsfolders(stream=self.stdout)
|
${cmd_name}: list the sub folders of the maildir.
${cmd_usage}
|
def do_ls(self, subcmd, opts, folder=""):
client = MdClient(self.maildir, filesystem=self.filesystem)
client.ls(
foldername = folder,
stream = self.stdout,
reverse = getattr(opts, "reverse", False),
grep = getattr(opts, "grep", None),
field = getattr(opts, "field", None),
since = float(getattr(opts, "since", -1))
)
|
${cmd_name}: list messages in the specified folder
${cmd_usage}
${cmd_option_list}
SINCE can be used with epoch times, for example:
md ls -s $(date '+%s')
|
def do_lisp(self, subcmd, opts, folder=""):
client = MdClient(self.maildir, filesystem=self.filesystem)
client.lisp(
foldername=folder,
stream=self.stdout,
reverse=getattr(opts, "reverse", False),
since=float(getattr(opts, "since", -1))
)
|
${cmd_name}: list messages in the specified folder in JSON format
${cmd_usage}
|
def do_make(self, subcmd, opts, path):
# Do we need to make this ".path" if it's relative?
d = path if path[0] == "/" else joinpath(self.maildir, "." + path)
os.makedirs(joinpath(d, "cur"))
os.makedirs(joinpath(d, "new"))
os.makedirs(joinpath(d, "tmp"))
os.makedirs(joinpath(d, "store"))
|
${cmd_name}: make a maildir at the specified path.
${cmd_usage}
If the path is relative then create under MAILDIR
else create at the absolute location.
|
def do_rm(self, subcmd, opts, message):
maildir = self.maildir
client = MdClient(maildir, filesystem=self.filesystem)
try:
client.remove(message)
except KeyError:
return 1
|
${cmd_name}: remove the specified message
${cmd_usage}
|
def do_mv(self, subcmd, opts, message, folder):
client = MdClient(self.maildir, filesystem=self.filesystem)
client.move(message, folder)
|
${cmd_name}: move the specified message to the specified folder
${cmd_usage}
|
def do_text(self, subcmd, opts, message):
client = MdClient(self.maildir, filesystem=self.filesystem)
client.gettext(message, self.stdout)
|
${cmd_name}: get the best text part of the specified message
${cmd_usage}
|
def do_raw(self, subcmd, opts, message):
client = MdClient(self.maildir)
client.getraw(message, self.stdout)
|
${cmd_name}: dump the complete raw message
${cmd_usage}
|
def do_rawpart(self, subcmd, opts, message):
client = MdClient(self.maildir, filesystem=self.filesystem)
partid = getattr(opts, "part", None)
if not partid:
client.getrawpart(message, self.stdout)
else:
client.getrawpartid(message, partid, self.stdout)
|
${cmd_name}: dump a part from the specified message
${cmd_usage}
${cmd_option_list}
|
def do_struct(self, subcmd, opts, message):
client = MdClient(self.maildir, filesystem=self.filesystem)
as_json = getattr(opts, "json", False)
client.getstruct(message, as_json=as_json, stream=self.stdout)
|
${cmd_name}: get the structure of the specified message
${cmd_usage}
${cmd_option_list}
|
def do_file(self, subcmd, opts, message):
client = MdClient(self.maildir, filesystem=self.filesystem)
client.get(message, self.stdout)
|
${cmd_name}: download the whole file of the message.
${cmd_usage}
|
def do_newfilter(self, subcmd, opts):
from mdlib.filterprocessor import RULES
print(RULES, file=self.stdout)
|
${cmd_name}: make a filterfile and spit it to stdout.
|
def do_storecheck(self, subcmd, opts):
from os.path import basename
from os.path import dirname
from os.path import exists as existspath
from os.path import islink
from os.path import join as joinpath
maildir = self.maildir
cur = joinpath(maildir, "cur")
new = joinpath(maildir, "new")
store = joinpath(maildir, "store")
found_list = []
# Loop through the folders checking that everything maps back to the store
for scandir in [cur, new]:
for f in os.listdir(scandir):
filename = joinpath(scandir, f)
try:
assert islink(filename)
store_location = os.readlink(filename)
assert existspath(store_location) and dirname(store_location) == store
except AssertionError:
print("%s was not a link into the store" % (
"/".join([
filename.split("/")[-2],
filename.split("/")[-1]
])
),
file=self.stdout)
else:
found_list.append(basename(store_location))
for storefile in os.listdir(store):
if storefile not in found_list:
print(
"%s found in store but not folders" % joinpath("store", storefile),
file=self.stdout
)
|
${cmd_name}: checks the store for files that may not be in the maildirs.
|
def form(context, form, **kwargs):
if not isinstance(form, (forms.BaseForm, TapeformFieldset)):
raise template.TemplateSyntaxError(
'Provided form should be a `Form` instance, actual type: {0}'.format(
form.__class__.__name__))
return render_to_string(
form.get_layout_template(kwargs.get('using', None)),
form.get_layout_context(),
)
|
The `form` template tag will render a tape-form enabled form using the template
provided by `get_layout_template` method of the form using the context generated
by `get_layout_context` method of the form.
Usage::
{% load tapeforms %}
{% form my_form %}
You can override the used layout template using the keyword argument `using`::
{% load tapeforms %}
{% form my_form using='other_form_layout_template.html' %}
:param form: The Django form to render.
:return: Rendered form (errors + hidden fields + fields) as HTML.
|
def formfield(context, bound_field, **kwargs):
if not isinstance(bound_field, forms.BoundField):
raise template.TemplateSyntaxError(
'Provided field should be a `BoundField` instance, actual type: {0}'.format(
bound_field.__class__.__name__))
return render_to_string(
bound_field.form.get_field_template(bound_field, kwargs.get('using', None)),
bound_field.form.get_field_context(bound_field),
)
|
The `formfield` template tag will render a form field of a tape-form enabled form
using the template provided by `get_field_template` method of the form together with
the context generated by `get_field_context` method of the form.
Usage::
{% load tapeforms %}
{% formfield my_form.my_field %}
You can override the used field template using the keyword argument `using`::
{% load tapeforms %}
{% formfield my_form.my_field using='other_field_template.html' %}
:param bound_field: The `BoundField` from a Django form to render.
:return: Rendered field (label + widget + other stuff) as HTML.
|
def resolve_node_modules(self):
'import the modules specified in init'
if not self.resolved_node_modules:
try:
self.resolved_node_modules = [
importlib.import_module(mod, self.node_package)
for mod in self.node_modules
]
except ImportError:
self.resolved_node_modules = []
raise
return self.resolved_node_modulef resolve_node_modules(self):
'import the modules specified in init'
if not self.resolved_node_modules:
try:
self.resolved_node_modules = [
importlib.import_module(mod, self.node_package)
for mod in self.node_modules
]
except ImportError:
self.resolved_node_modules = []
raise
return self.resolved_node_modules
|
import the modules specified in init
|
def register(self, name, func, fields, subscribe_to, entry_point, ignore):
'''
Register a named function in the graph
:param name: name to register
:type name: :py:class:`str`
:param func: function to remember and call
:type func: callable
``fields``, ``subscribe_to`` and ``entry_point`` are the same as in
:py:meth:`Router.node`.
'''
self.fields[name] = fields
self.functions[name] = func
self.register_route(subscribe_to, name)
if ignore:
self.register_ignore(ignore, name)
if entry_point:
self.add_entry_point(name)
self.logger.info('registered %s', namef register(self, name, func, fields, subscribe_to, entry_point, ignore):
'''
Register a named function in the graph
:param name: name to register
:type name: :py:class:`str`
:param func: function to remember and call
:type func: callable
``fields``, ``subscribe_to`` and ``entry_point`` are the same as in
:py:meth:`Router.node`.
'''
self.fields[name] = fields
self.functions[name] = func
self.register_route(subscribe_to, name)
if ignore:
self.register_ignore(ignore, name)
if entry_point:
self.add_entry_point(name)
self.logger.info('registered %s', name)
|
Register a named function in the graph
:param name: name to register
:type name: :py:class:`str`
:param func: function to remember and call
:type func: callable
``fields``, ``subscribe_to`` and ``entry_point`` are the same as in
:py:meth:`Router.node`.
|
def add_entry_point(self, destination):
'''\
Add an entry point
:param destination: node to route to initially
:type destination: str
'''
self.routes.setdefault('__entry_point', set()).add(destination)
return self.routes['__entry_point'f add_entry_point(self, destination):
'''\
Add an entry point
:param destination: node to route to initially
:type destination: str
'''
self.routes.setdefault('__entry_point', set()).add(destination)
return self.routes['__entry_point']
|
\
Add an entry point
:param destination: node to route to initially
:type destination: str
|
def register_ignore(self, origins, destination):
'''
Add routes to the ignore dictionary
:param origins: a number of origins to register
:type origins: :py:class:`str` or iterable of :py:class:`str`
:param destination: where the origins should point to
:type destination: :py:class:`str`
Ignore dictionary takes the following form::
{'node_a': set(['node_b', 'node_c']),
'node_b': set(['node_d'])}
'''
if not isinstance(origins, list):
origins = [origins]
self.ignore_regexes.setdefault(destination, [re.compile(origin) for origin in origins])
self.regenerate_routes()
return self.ignore_regexes[destinationf register_ignore(self, origins, destination):
'''
Add routes to the ignore dictionary
:param origins: a number of origins to register
:type origins: :py:class:`str` or iterable of :py:class:`str`
:param destination: where the origins should point to
:type destination: :py:class:`str`
Ignore dictionary takes the following form::
{'node_a': set(['node_b', 'node_c']),
'node_b': set(['node_d'])}
'''
if not isinstance(origins, list):
origins = [origins]
self.ignore_regexes.setdefault(destination, [re.compile(origin) for origin in origins])
self.regenerate_routes()
return self.ignore_regexes[destination]
|
Add routes to the ignore dictionary
:param origins: a number of origins to register
:type origins: :py:class:`str` or iterable of :py:class:`str`
:param destination: where the origins should point to
:type destination: :py:class:`str`
Ignore dictionary takes the following form::
{'node_a': set(['node_b', 'node_c']),
'node_b': set(['node_d'])}
|
def regenerate_routes(self):
'regenerate the routes after a new route is added'
for destination, origins in self.regexes.items():
# we want only the names that match the destination regexes.
resolved = [
name for name in self.names
if name is not destination
and any(origin.search(name) for origin in origins)
]
ignores = self.ignore_regexes.get(destination, [])
for origin in resolved:
destinations = self.routes.setdefault(origin, set())
if any(ignore.search(origin) for ignore in ignores):
self.logger.info('ignoring route "%s" -> "%s"', origin, destination)
try:
destinations.remove(destination)
self.logger.debug('removed "%s" -> "%s"', origin, destination)
except KeyError:
pass
continue
if destination not in destinations:
self.logger.info('added route "%s" -> "%s"', origin, destination)
destinations.add(destinationf regenerate_routes(self):
'regenerate the routes after a new route is added'
for destination, origins in self.regexes.items():
# we want only the names that match the destination regexes.
resolved = [
name for name in self.names
if name is not destination
and any(origin.search(name) for origin in origins)
]
ignores = self.ignore_regexes.get(destination, [])
for origin in resolved:
destinations = self.routes.setdefault(origin, set())
if any(ignore.search(origin) for ignore in ignores):
self.logger.info('ignoring route "%s" -> "%s"', origin, destination)
try:
destinations.remove(destination)
self.logger.debug('removed "%s" -> "%s"', origin, destination)
except KeyError:
pass
continue
if destination not in destinations:
self.logger.info('added route "%s" -> "%s"', origin, destination)
destinations.add(destination)
|
regenerate the routes after a new route is added
|
def route(self, origin, message):
'''\
Using the routing dictionary, dispatch a message to all subscribers
:param origin: name of the origin node
:type origin: :py:class:`str`
:param message: message to dispatch
:type message: :py:class:`emit.message.Message` or subclass
'''
# side-effect: we have to know all the routes before we can route. But
# we can't resolve them while the object is initializing, so we have to
# do it just in time to route.
self.resolve_node_modules()
if not self.routing_enabled:
return
subs = self.routes.get(origin, set())
for destination in subs:
self.logger.debug('routing "%s" -> "%s"', origin, destination)
self.dispatch(origin, destination, messagef route(self, origin, message):
'''\
Using the routing dictionary, dispatch a message to all subscribers
:param origin: name of the origin node
:type origin: :py:class:`str`
:param message: message to dispatch
:type message: :py:class:`emit.message.Message` or subclass
'''
# side-effect: we have to know all the routes before we can route. But
# we can't resolve them while the object is initializing, so we have to
# do it just in time to route.
self.resolve_node_modules()
if not self.routing_enabled:
return
subs = self.routes.get(origin, set())
for destination in subs:
self.logger.debug('routing "%s" -> "%s"', origin, destination)
self.dispatch(origin, destination, message)
|
\
Using the routing dictionary, dispatch a message to all subscribers
:param origin: name of the origin node
:type origin: :py:class:`str`
:param message: message to dispatch
:type message: :py:class:`emit.message.Message` or subclass
|
def dispatch(self, origin, destination, message):
'''\
dispatch a message to a named function
:param destination: destination to dispatch to
:type destination: :py:class:`str`
:param message: message to dispatch
:type message: :py:class:`emit.message.Message` or subclass
'''
func = self.functions[destination]
self.logger.debug('calling %r directly', func)
return func(_origin=origin, **messagef dispatch(self, origin, destination, message):
'''\
dispatch a message to a named function
:param destination: destination to dispatch to
:type destination: :py:class:`str`
:param message: message to dispatch
:type message: :py:class:`emit.message.Message` or subclass
'''
func = self.functions[destination]
self.logger.debug('calling %r directly', func)
return func(_origin=origin, **message)
|
\
dispatch a message to a named function
:param destination: destination to dispatch to
:type destination: :py:class:`str`
:param message: message to dispatch
:type message: :py:class:`emit.message.Message` or subclass
|
def wrap_result(self, name, result):
'''
Wrap a result from a function with it's stated fields
:param name: fields to look up
:type name: :py:class:`str`
:param result: return value from function. Will be converted to tuple.
:type result: anything
:raises: :py:exc:`ValueError` if name has no associated fields
:returns: :py:class:`dict`
'''
if not isinstance(result, tuple):
result = tuple([result])
try:
return dict(zip(self.fields[name], result))
except KeyError:
msg = '"%s" has no associated fields'
self.logger.exception(msg, name)
raise ValueError(msg % namef wrap_result(self, name, result):
'''
Wrap a result from a function with it's stated fields
:param name: fields to look up
:type name: :py:class:`str`
:param result: return value from function. Will be converted to tuple.
:type result: anything
:raises: :py:exc:`ValueError` if name has no associated fields
:returns: :py:class:`dict`
'''
if not isinstance(result, tuple):
result = tuple([result])
try:
return dict(zip(self.fields[name], result))
except KeyError:
msg = '"%s" has no associated fields'
self.logger.exception(msg, name)
raise ValueError(msg % name)
|
Wrap a result from a function with it's stated fields
:param name: fields to look up
:type name: :py:class:`str`
:param result: return value from function. Will be converted to tuple.
:type result: anything
:raises: :py:exc:`ValueError` if name has no associated fields
:returns: :py:class:`dict`
|
def get_name(self, func):
'''
Get the name to reference a function by
:param func: function to get the name of
:type func: callable
'''
if hasattr(func, 'name'):
return func.name
return '%s.%s' % (
func.__module__,
func.__name__
f get_name(self, func):
'''
Get the name to reference a function by
:param func: function to get the name of
:type func: callable
'''
if hasattr(func, 'name'):
return func.name
return '%s.%s' % (
func.__module__,
func.__name__
)
|
Get the name to reference a function by
:param func: function to get the name of
:type func: callable
|
def coerce(self, value):
if isinstance(value, bool):
return value
if not hasattr(value, 'lower'):
raise TypeError('Value is not bool or string.')
if value.lower() in ('yes', 'true', '1'):
return True
if value.lower() in ('no', 'false', '0'):
return False
raise ValueError('Could not coerce {0} to a bool.'.format(value))
|
Convert text values into boolean values.
True values are (case insensitive): 'yes', 'true', '1'. False values
are (case insensitive): 'no', 'false', '0'.
Args:
value (str or bool): The value to coerce.
Raises:
TypeError: If the value is not a bool or string.
ValueError: If the value is not bool or an acceptable value.
Returns:
bool: The True/False value represented.
|
def main():
if len(argv) < 2:
print 'Usage: '
print ' Get A String %s CFG_fileA FST_fileB' % argv[0]
return
alphabet = createalphabet()
cfgtopda = CfgPDA(alphabet)
print '* Parsing Grammar:',
mma = cfgtopda.yyparse(argv[1])
print 'OK'
flex_a = Flexparser(alphabet)
print '* Parsing Regex:',
mmb = flex_a.yyparse(argv[2])
print mmb
print 'OK'
print '* Minimize Automaton:',
mmb.minimize()
print 'OK'
print mmb
print '* Diff:',
ops = PdaDiff(mma, mmb, alphabet)
mmc = ops.diff()
print 'OK'
print '* Get String:',
print ops.get_string()
|
Testing function for PDA - DFA Diff Operation
|
def _delta(self, graph, cur_state, char):
for arc in cur_state.arcs:
if graph.isyms.find(arc.ilabel) == char:
return graph[arc.nextstate]
return None
|
Args:
graph (Fst Acceptor): The DFA
cur_state (Fst State): The current State
char (Char): The input character
Returns:
(Fst State): The destination state
|
def diff(self):
self.mmb.complement(self.alphabet)
self.mmb.minimize()
print 'start intersection'
self.mmc = self._intesect()
print 'end intersection'
return self.mmc
|
The Difference between a PDA and a DFA
|
def refresh_devices(self):
'''Queries hub for list of devices, and creates new device objects'''
try:
response = self.api.get("/api/v2/devices", {'properties':'all'})
for device_data in response['DeviceList']:
self.devices.append(Device(device_data, self))
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value)f refresh_devices(self):
'''Queries hub for list of devices, and creates new device objects'''
try:
response = self.api.get("/api/v2/devices", {'properties':'all'})
for device_data in response['DeviceList']:
self.devices.append(Device(device_data, self))
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value))
|
Queries hub for list of devices, and creates new device objects
|
def refresh_details(self):
'''Query hub and refresh all details of a device,
but NOT status, includes grouplist not present in
refresh_all_devices'''
try:
return self.api_iface._api_get("/api/v2/devices/" + str(self.device_id))
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value)f refresh_details(self):
'''Query hub and refresh all details of a device,
but NOT status, includes grouplist not present in
refresh_all_devices'''
try:
return self.api_iface._api_get("/api/v2/devices/" + str(self.device_id))
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value))
|
Query hub and refresh all details of a device,
but NOT status, includes grouplist not present in
refresh_all_devices
|
def send_command(self, command):
'''Send a command to a device'''
data = {"command": command, "device_id": self.device_id}
try:
response = self.api_iface._api_post("/api/v2/commands", data)
return Command(response, self)
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value)f send_command(self, command):
'''Send a command to a device'''
data = {"command": command, "device_id": self.device_id}
try:
response = self.api_iface._api_post("/api/v2/commands", data)
return Command(response, self)
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value))
|
Send a command to a device
|
def _update_details(self,data):
'''Intakes dict of details, and sets necessary properties
in device'''
# DeviceName, IconID, HouseID, DeviceID always present
self.device_id = data['DeviceID']
self.device_name = data['DeviceName']
self.properties = datf _update_details(self,data):
'''Intakes dict of details, and sets necessary properties
in device'''
# DeviceName, IconID, HouseID, DeviceID always present
self.device_id = data['DeviceID']
self.device_name = data['DeviceName']
self.properties = data
|
Intakes dict of details, and sets necessary properties
in device
|
def _update_details(self,data):
'''Intakes dict of details, and sets necessary properties
in command'''
for api_name in self._properties:
if api_name in data:
setattr(self, "_" + api_name, data[api_name])
else:
# Only set to blank if not initialized
try:
getattr(self, "_" + api_name)
except AttributeError:
setattr(self, "_" + api_name, ''f _update_details(self,data):
'''Intakes dict of details, and sets necessary properties
in command'''
for api_name in self._properties:
if api_name in data:
setattr(self, "_" + api_name, data[api_name])
else:
# Only set to blank if not initialized
try:
getattr(self, "_" + api_name)
except AttributeError:
setattr(self, "_" + api_name, '')
|
Intakes dict of details, and sets necessary properties
in command
|
def query_status(self):
'''Query the hub for the status of this command'''
try:
data = self.api_iface._api_get(self.link)
self._update_details(data)
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value)f query_status(self):
'''Query the hub for the status of this command'''
try:
data = self.api_iface._api_get(self.link)
self._update_details(data)
except APIError as e:
print("API error: ")
for key,value in e.data.iteritems:
print(str(key) + ": " + str(value))
|
Query the hub for the status of this command
|
def tracks(self):
if self._tracks is None:
self._tracks = TrackList(self.version, self.id)
return self._tracks
|
Tracks list context
:return: Tracks list context
|
def list(self, ids, market=values.UNSET):
params = values.of({
'ids': ','.join(ids),
'market': market
})
response = self.version.request('GET', '/albums', params=params)
return AlbumPage(self.version, response.json(), 'albums')
|
List albums
:param List[str] ids: List of albums ids
:param str market: Market locale
:return: Page of Albums
:rtype: AlbumPage
|
def to_string(self):
if self.major == -1:
major_str = 'x'
else:
major_str = self.major
if self.minor == -1:
minor_str = 'x'
else:
minor_str = self.minor
if self.patch == -1:
patch_str = 'x'
else:
patch_str = self.patch
return '{0}_{1}_{2}'.format(major_str, minor_str, patch_str)
|
stringifies version
:return: string of version
|
def find(self, binding_id, instance):
binding = AtlasServiceBinding.Binding(binding_id, instance)
self.backend.storage.populate(binding)
return binding
|
find an instance
Create a new instance and populate it with data stored if it exists.
Args:
binding_id (string): UUID of the binding
instance (AtlasServiceInstance.Instance): instance
Returns:
AtlasServiceBinding: A binding
|
def bind(self, binding, parameters):
if not binding.isProvisioned():
# Update binding parameters
binding.parameters = parameters
# Credentials
creds = self.backend.config.generate_binding_credentials(binding)
# Binding
p = self.backend.config.generate_binding_permissions(
binding,
DatabaseUsersPermissionsSpecs(creds["username"],creds["password"])
)
try:
self.backend.atlas.DatabaseUsers.create_a_database_user(p)
except ErrAtlasConflict:
# The user already exists. This is not an issue because this is possible that we
# created it in a previous call that failed later on the broker.
pass
self.backend.storage.store(binding)
# Bind done
return Binding(BindState.SUCCESSFUL_BOUND,
credentials = creds)
elif binding.parameters == parameters:
if self.backend.config.isGenerateBindingCredentialsPredictible():
# Identical and credentials generation is predictible so we can return credentials again.
creds = self.backend.config.generate_binding_credentials(binding)
return Binding(BindState.IDENTICAL_ALREADY_EXISTS,
credentials = creds)
# Identical but credentials generation is NOT predictible. So we are breaking the spec to avoid
# wrong data injection. In this case we trigger a conflicting parameters for the existing binding depsite
# this is not the case.
raise ErrBindingAlreadyExists()
else:
# Different parameters ...
raise ErrBindingAlreadyExists()
|
Create the binding
Args:
binding (AtlasServiceBinding.Binding): Existing or New binding
parameters (dict): Parameters for the binding
Returns:
Binding: Status
Raises:
ErrBindingAlreadyExists: If binding exists but with different parameters
|
def unbind(self, binding):
username = self.backend.config.generate_binding_username(binding)
try:
self.backend.atlas.DatabaseUsers.delete_a_database_user(username)
except ErrAtlasNotFound:
# The user does not exist. This is not an issue because this is possible that we
# removed it in a previous call that failed later on the broker.
# This cover a manually deleted user case too.
pass
self.backend.storage.remove(binding)
|
Unbind the instance
Args:
binding (AtlasServiceBinding.Binding): Existing or New binding
|
def extension(names):
for name in names:
if not NAME_PATTERN.match(name):
raise ValueError('invalid extension name: %s' % name)
def decorator(f, names=names):
return Extension(f, names=names)
return decorator
|
Makes a function to be an extension.
|
def register(self, extensions):
for ext in reversed(extensions):
for name in ext.names:
try:
self._extensions[name].appendleft(ext)
except KeyError:
self._extensions[name] = deque([ext])
|
Registers extensions.
|
def eval_extensions(self, value, name, option, format):
try:
exts = self._extensions[name]
except KeyError:
raise ValueError('no suitable extension: %s' % name)
for ext in exts:
rv = ext(self, value, name, option, format)
if rv is not None:
return rv
|
Evaluates extensions in the registry. If some extension handles the
format string, it returns a string. Otherwise, returns ``None``.
|
def GenerateNewFileName(self):
if self.showInfo.showName is not None and self.showInfo.seasonNum is not None and \
self.showInfo.episodeNum is not None and self.showInfo.episodeName is not None:
ext = os.path.splitext(self.fileInfo.origPath)[1]
newFileName = "{0}.S{1}E{2}".format(self.showInfo.showName, self.showInfo.seasonNum, \
self.showInfo.episodeNum)
for episodeNum in self.showInfo.multiPartEpisodeNumbers:
newFileName = newFileName + "_{0}".format(episodeNum)
newFileName = newFileName + ".{0}{1}".format(self.showInfo.episodeName, ext)
newFileName = util.StripSpecialCharacters(newFileName)
return newFileName
|
Create new file name from show name, season number, episode number
and episode name in format ShowName.S<NUM>.E<NUM>.EpisodeName.
Returns
----------
string
New file name in format ShowName.S<NUM>.E<NUM>.EpisodeName.
|
def GenerateNewFilePath(self, fileDir = None):
newFileName = self.GenerateNewFileName()
if newFileName is not None:
if fileDir is None:
fileDir = os.path.dirname(self.fileInfo.origPath)
self.fileInfo.newPath = os.path.join(fileDir, newFileName)
|
Create new file path. If a fileDir is provided it will be used otherwise
the original file path is used. Updates file info object with new path.
Parameters
----------
fileDir : string [optional : default = None]
Optional file directory
|
def Print(self):
goodlogging.Log.Info("TVFILE", "TV File details are:")
goodlogging.Log.IncreaseIndent()
goodlogging.Log.Info("TVFILE", "Original File Path = {0}".format(self.fileInfo.origPath))
if self.showInfo.showName is not None:
goodlogging.Log.Info("TVFILE", "Show Name (from guide) = {0}".format(self.showInfo.showName))
elif self.fileInfo.showName is not None:
goodlogging.Log.Info("TVFILE", "Show Name (from file) = {0}".format(self.fileInfo.showName))
if self.showInfo.seasonNum is not None and self.showInfo.episodeNum is not None:
goodlogging.Log.Info("TVFILE", "Season & Episode = S{0}E{1}".format(self.showInfo.seasonNum, self.showInfo.episodeNum))
if self.showInfo.episodeName is not None:
goodlogging.Log.Info("TVFILE", "Episode Name: = {0}".format(self.showInfo.episodeName))
if self.fileInfo.newPath is not None:
goodlogging.Log.Info("TVFILE", "New File Path = {0}".format(self.fileInfo.newPath))
goodlogging.Log.DecreaseIndent()
|
Print contents of showInfo and FileInfo object
|
def connectProcess(connection, processProtocol, commandLine='', env={},
usePTY=None, childFDs=None, *args, **kwargs):
processOpenDeferred = defer.Deferred()
process = SSHProcess(processProtocol, commandLine, env, usePTY, childFDs,
*args, **kwargs)
process.processOpen = processOpenDeferred.callback
process.openFailed = processOpenDeferred.errback
connection.openChannel(process)
return processOpenDeferred
|
Opens a SSHSession channel and connects a ProcessProtocol to it
@param connection: the SSH Connection to open the session channel on
@param processProtocol: the ProcessProtocol instance to connect to the process
@param commandLine: the command line to execute the process
@param env: optional environment variables to set for the process
@param usePTY: if set, request a PTY for the process
@param childFDs: custom child file descriptors for the process
|
def get_api_publisher(self, social_user):
def _post(**kwargs):
api = self.get_api(social_user)
response = api.wall.post(**kwargs)
return response
return _post
|
owner_id - VK user or group
from_group - 1 by group, 0 by user
message - text
attachments - comma separated links or VK resources ID's
and other https://vk.com/dev.php?method=wall.post
|
def get_api_publisher(self, social_user):
def _post(**kwargs):
api = self.get_api(social_user)
author = {
'group_id': kwargs.get('group_id'),
'user_id': kwargs.get('user_id'),
}
server_data = api.photos.getWallUploadServer(**author)
attachments = []
for _file in kwargs['files']:
upload_data = requests.post(
server_data['upload_url'], files={"photo": _file}).json()
upload_data.update(author)
photos_data = api.photos.saveWallPhoto(**upload_data)
attachments.append('photo{owner_id}_{id}'.format(**photos_data[0]))
del kwargs['files']
kwargs['attachments'] = ','.join(attachments)
response = api.wall.post(**kwargs)
server_data.update(response)
return server_data
return _post
|
files: {'file0':<file>}
message: 'mess'
|
def call_builder_init(cls, kb_app, sphinx_app: Sphinx):
# Find and commit docs project plugins
conf_dir = sphinx_app.confdir
plugins_dir = sphinx_app.config.kaybee_settings.plugins_dir
full_plugins_dir = os.path.join(conf_dir, plugins_dir)
if os.path.exists(full_plugins_dir):
sys.path.insert(0, conf_dir)
plugin_package = importlib.import_module(plugins_dir)
importscan.scan(plugin_package)
else:
logger.info(f'## Kaybee: No plugin dir at {plugins_dir}')
dectate.commit(kb_app)
for callback in cls.get_callbacks(kb_app, SphinxEvent.BI):
callback(kb_app, sphinx_app)
|
On builder init event, commit registry and do callbacks
|
def call_purge_doc(cls, kb_app, sphinx_app: Sphinx,
sphinx_env: BuildEnvironment,
docname: str):
for callback in EventAction.get_callbacks(kb_app, SphinxEvent.EPD):
callback(kb_app, sphinx_app, sphinx_env, docname)
|
On env-purge-doc, do callbacks
|
def call_env_before_read_docs(cls, kb_app, sphinx_app: Sphinx,
sphinx_env: BuildEnvironment,
docnames: List[str]):
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.EBRD):
callback(kb_app, sphinx_app, sphinx_env, docnames)
|
On env-read-docs, do callbacks
|
def call_env_doctree_read(cls, kb_app, sphinx_app: Sphinx,
doctree: doctree):
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.DREAD):
callback(kb_app, sphinx_app, doctree)
|
On doctree-read, do callbacks
|
def call_doctree_resolved(cls, kb_app, sphinx_app: Sphinx,
doctree: doctree,
fromdocname: str):
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.DRES):
callback(kb_app, sphinx_app, doctree, fromdocname)
|
On doctree-resolved, do callbacks
|
def call_env_updated(cls, kb_app,
sphinx_app: Sphinx,
sphinx_env: BuildEnvironment):
for callback in EventAction.get_callbacks(kb_app, SphinxEvent.EU):
callback(kb_app, sphinx_app, sphinx_env)
|
On the env-updated event, do callbacks
|
def call_html_collect_pages(cls, kb_app, sphinx_app: Sphinx):
EventAction.get_callbacks(kb_app,
SphinxEvent.HCP)
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.HCP):
yield callback(kb_app, sphinx_app)
|
On html-collect-pages, do callbacks
|
def call_env_check_consistency(cls, kb_app, builder: StandaloneHTMLBuilder,
sphinx_env: BuildEnvironment):
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.ECC):
callback(kb_app, builder, sphinx_env)
|
On env-check-consistency, do callbacks
|
def call_missing_reference(cls, kb_app, sphinx_app: Sphinx,
sphinx_env: BuildEnvironment,
node,
contnode,
):
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.MR):
return callback(kb_app, sphinx_app, sphinx_env, node, contnode)
|
On doctree-resolved, do callbacks
|
def call_html_page_context(cls, kb_app, sphinx_app: Sphinx,
pagename: str,
templatename: str,
context,
doctree: doctree
):
# We need to let one, and only one, callback return the name of
# the template. Detect multiple and raise an exception.
new_templatename = None
for callback in EventAction.get_callbacks(kb_app,
SphinxEvent.HPC):
# The protocol: the one controlling callback will return a value
# with a dictionary of {'templatename': 'sometemplate'}
result = callback(kb_app, sphinx_app, pagename, templatename,
context,
doctree)
if result and isinstance(result,
dict) and 'templatename' in result:
if new_templatename is not None:
raise AssertionError('Multiple handlers returning')
new_templatename = result['templatename']
return new_templatename
|
On doctree-resolved, do callbacks
|
def get_layout_template(self, template_name=None):
if template_name:
return template_name
if self.layout_template:
return self.layout_template
return defaults.LAYOUT_DEFAULT_TEMPLATE
|
Returns the layout template to use when rendering the form to HTML.
Preference of template selection:
1. Provided method argument `template_name`
2. Form class property `layout_template`
3. Globally defined default template from `defaults.LAYOUT_DEFAULT_TEMPLATE`
:param template_name: Optional template to use instead of other configurations.
:return: Template name to use when rendering the form.
|
def get_layout_context(self):
errors = self.non_field_errors()
for field in self.hidden_fields():
errors.extend(field.errors)
return {
'form': self,
'errors': errors,
'hidden_fields': self.hidden_fields(),
'visible_fields': self.visible_fields(),
}
|
Returns the context which is used when rendering the form to HTML.
The generated template context will contain the following variables:
* form: `Form` instance
* errors: `ErrorList` instance with non field errors and hidden field errors
* hidden_fields: All hidden fields to render.
* visible_fields: All visible fields to render.
:return: Template context for form rendering.
|
def full_clean(self, *args, **kwargs):
super().full_clean(*args, **kwargs)
for field in self.errors:
if field != NON_FIELD_ERRORS:
self.apply_widget_invalid_options(field)
|
The full_clean method is hijacked to apply special treatment to invalid
field inputs. For example adding extra options/classes to widgets.
|
def get_field_template(self, bound_field, template_name=None):
if template_name:
return template_name
templates = self.field_template_overrides or {}
template_name = templates.get(bound_field.name, None)
if template_name:
return template_name
template_name = templates.get(bound_field.field.__class__, None)
if template_name:
return template_name
if self.field_template:
return self.field_template
return defaults.FIELD_DEFAULT_TEMPLATE
|
Returns the field template to use when rendering a form field to HTML.
Preference of template selection:
1. Provided method argument `template_name`
2. Template from `field_template_overrides` selected by field name
3. Template from `field_template_overrides` selected by field class
4. Form class property `field_template`
5. Globally defined default template from `defaults.LAYOUT_FIELD_TEMPLATE`
:param bound_field: `BoundField` instance to select a template for.
:param template_name: Optional template to use instead of other configurations.
:return: Template name to use when rendering the form field.
|
def get_field_label_css_class(self, bound_field):
class_name = self.field_label_css_class
if bound_field.errors and self.field_label_invalid_css_class:
class_name = join_css_class(
class_name, self.field_label_invalid_css_class)
return class_name or None
|
Returns the optional label CSS class to use when rendering a field template.
By default, returns the Form class property `field_label_css_class`. If the
field has errors and the Form class property `field_label_invalid_css_class`
is defined, its value is appended to the CSS class.
:param bound_field: `BoundField` instance to return CSS class for.
:return: A CSS class string or `None`
|
def apply_widget_options(self, field_name):
widget = self.fields[field_name].widget
if isinstance(widget, forms.DateInput):
widget.input_type = 'date'
if isinstance(widget, forms.TimeInput):
widget.input_type = 'time'
if isinstance(widget, forms.SplitDateTimeWidget):
widget.widgets[0].input_type = 'date'
widget.widgets[1].input_type = 'time'
|
Applies additional widget options like changing the input type of DateInput
and TimeInput to "date" / "time" to enable Browser date pickers or other
attributes/properties.
|
def apply_widget_template(self, field_name):
field = self.fields[field_name]
template_name = self.get_widget_template(field_name, field)
if template_name:
field.widget.template_name = template_name
|
Applies widget template overrides if available.
The method uses the `get_widget_template` method to determine if the widget
template should be exchanged. If a template is available, the template_name
property of the widget instance is updated.
:param field_name: A field name of the form.
|
def get_widget_template(self, field_name, field):
templates = self.widget_template_overrides or {}
template_name = templates.get(field_name, None)
if template_name:
return template_name
template_name = templates.get(field.widget.__class__, None)
if template_name:
return template_name
return None
|
Returns the optional widget template to use when rendering the widget
for a form field.
Preference of template selection:
1. Template from `widget_template_overrides` selected by field name
2. Template from `widget_template_overrides` selected by widget class
By default, returns `None` which means "use Django's default widget template".
:param field_name: The field name to select a widget template for.
:param field: `Field` instance to return a widget template.
:return: Template name to use when rendering the widget or `None`
|
def apply_widget_css_class(self, field_name):
field = self.fields[field_name]
class_name = self.get_widget_css_class(field_name, field)
if class_name:
field.widget.attrs['class'] = join_css_class(
field.widget.attrs.get('class', None), class_name)
|
Applies CSS classes to widgets if available.
The method uses the `get_widget_css_class` method to determine if the widget
CSS class should be changed. If a CSS class is returned, it is appended to
the current value of the class property of the widget instance.
:param field_name: A field name of the form.
|
def apply_widget_invalid_options(self, field_name):
field = self.fields[field_name]
class_name = self.get_widget_invalid_css_class(field_name, field)
if class_name:
field.widget.attrs['class'] = join_css_class(
field.widget.attrs.get('class', None), class_name)
field.widget.attrs['aria-invalid'] = 'true'
|
Applies additional widget options for an invalid field.
This method is called when there is some error on a field to apply
additional options on its widget. It does the following:
* Sets the aria-invalid property of the widget for accessibility.
* Adds an invalid CSS class, which is determined by the returned value
of `get_widget_invalid_css_class` method. If a CSS class is returned,
it is appended to the current value of the class property of the widget.
:param field_name: A field name of the form.
|
def use_quandl_data(self, authtoken):
dfs = {}
st = self.start.strftime("%Y-%m-%d")
at = authtoken
for pair in self.pairs:
symbol = "".join(pair)
qsym = "CURRFX/{}".format(symbol)
dfs[symbol] = qdl.get(qsym,authtoken=at, trim_start=st)['Rate']
self.build_conversion_table(dfs)
|
Use quandl data to build conversion table
|
def use_trump_data(self, symbols):
dfs = {sym.units : sym.df[sym.name] for sym in symbols}
self.build_conversion_table(dfs)
|
Use trump data to build conversion table
symbols :
list of symbols:
will attempt to use units to build the conversion table,
strings represent symbol names.
|
def build_conversion_table(self, dataframes):
self.data = pd.DataFrame(dataframes)
tmp_pairs = [s.split("/") for s in self.data.columns]
self.data.columns = pd.MultiIndex.from_tuples(tmp_pairs)
|
Build conversion table from a dictionary of dataframes
|
def match_tweet(self, tweet, user_stream):
if user_stream:
if len(self.track) > 0:
return self.is_tweet_match_track(tweet)
return True
return self.is_tweet_match_track(tweet) or self.is_tweet_match_follow(tweet)
|
Check if a tweet matches the defined criteria
:param tweet: The tweet in question
:type tweet: :class:`~responsebot.models.Tweet`
:return: True if matched, False otherwise
|
def find(self, _id, instance = None):
if instance is None:
# We are looking for an instance
return self.service_instance.find(_id)
else:
# We are looking for a binding
return self.service_binding.find(_id, instance)
|
Find
Args:
_id (str): instance id or binding Id
Keyword Arguments:
instance (AtlasServiceInstance.Instance): Existing instance
Returns:
AtlasServiceInstance.Instance or AtlasServiceBinding.Binding: An instance or binding.
|
def create(self, instance, parameters, existing=True):
return self.service_instance.create(instance, parameters, existing)
|
Create an instance
Args:
instance (AtlasServiceInstance.Instance): Existing or New instance
parameters (dict): Parameters for the instance
Keyword Arguments:
existing (bool): True (use an existing cluster), False (create a new cluster)
Returns:
ProvisionedServiceSpec: Status
|
def index(self, req, drivers):
result = []
for driver in drivers:
result.append(driver.list_network(req.params))
data = {
'action': "index",
'controller': "network",
'cloud': req.environ['calplus.cloud'],
'result': result
}
return data
|
List all network
List all of netowrks on some special cloud
with:
:Param req
:Type object Request
|
def delete(self, req, driver):
response = driver.delete_network(req.params, id)
data = {
'action': "delete",
'controller': "network",
'id': id,
'cloud': req.environ['calplus.cloud'],
'response': response
}
return data
|
Delete a network
Delete a specific netowrk with id on special cloud
with:
:Param req
:Type object Request
|
def update(self, req, driver):
response = driver.update_network(req.params, id)
data = {
'action': "update",
'controller': "network",
'id': id,
'cloud': req.environ['calplus.cloud'],
'response': response
}
return data
|
Update a network
Update a specific netowrk with id on special cloud
with:
:Param req
:Type object Request
|
def create(self, req, driver):
response = driver.create_network(req.params)
data = {
'action': "create",
'controller': "network",
'cloud': req.environ['calplus.cloud'],
'response': response
}
return data
|
Create a network
Create a new netowrk on special cloud
with:
:Param req
:Type object Request
|
def get(self, req, driver):
response = driver.get_network(req.params, id)
data = {
'action': "get",
'controller': "network",
'id': id,
'cloud': req.environ['calplus.cloud'],
'response': response
}
return data
|
Get info of a network
Get info of a specific netowrk with id on special cloud
with:
:Param req
:Type object Request
|
def attach_igw(self, req, driver):
igw = driver.get_igw(req.params)
if igw is None:
igw = driver.create_igw(req.params)
response = driver.attach_igw(req.params, igw)
data = {
'action': 'attach_igw',
'controller': 'network',
'id': id,
'cloud': req.environ['calplus.cloud'],
'response': response
}
return data
|
Attach network to Internet gateway
:Param req
:Type object Request
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.