Search is not available for this dataset
text stringlengths 75 104k |
|---|
def check_dict_expected_keys(self, expected_keys, current, dict_name):
""" Check that we don't have unknown keys in a dictionary.
It does not raise an error if we have less keys than expected.
"""
if not isinstance(current, dict):
raise ParseError(u"'{}' key must be a dict".... |
def parse(self):
"""Check input and return a :class:`Migration` instance."""
if not self.parsed.get('migration'):
raise ParseError(u"'migration' key is missing", YAML_EXAMPLE)
self.check_dict_expected_keys(
{'options', 'versions'}, self.parsed['migration'], 'migration',
... |
def _parse_migrations(self):
"""Build a :class:`Migration` instance."""
migration = self.parsed['migration']
options = self._parse_options(migration)
versions = self._parse_versions(migration, options)
return Migration(versions, options) |
def _parse_options(self, migration):
"""Build :class:`MigrationOption` and
:class:`MigrationBackupOption` instances."""
options = migration.get('options', {})
install_command = options.get('install_command')
backup = options.get('backup')
if backup:
self.check... |
def set_message(self, title, msg, typ, url=None):
"""
Sets user notification message.
Args:
title: Msg. title
msg: Msg. text
typ: Msg. type
url: Additional URL (if exists)
Returns:
Message ID.
"""
return self.... |
def is_auth(self):
"""
A property that indicates if current user is logged in or not.
Returns:
Boolean.
"""
if self.user_id is None:
self.user_id = self.session.get('user_id')
return bool(self.user_id) |
def has_permission(self, perm):
"""
Checks if current user (or role) has the given permission.
Args:
perm: Permmission code or object.
Depends on the :attr:`~zengine.auth.auth_backend.AuthBackend` implementation.
Returns:
Boolean.
"""
... |
def msg_box(self, msg, title=None, typ='info'):
"""
Create a message box
:param str msg:
:param str title:
:param str typ: 'info', 'error', 'warning'
"""
self.output['msgbox'] = {'type': typ, "title": title or msg[:20], "msg": msg} |
def sendoff_current_user(self):
"""
Tell current user that s/he finished it's job for now.
We'll notify if workflow arrives again to his/her WF Lane.
"""
msgs = self.task_data.get('LANE_CHANGE_MSG', DEFAULT_LANE_CHANGE_MSG)
self.msg_box(title=msgs['title'], msg=msgs['body... |
def invite_other_parties(self, possible_owners):
"""
Invites the next lane's (possible) owner(s) to participate
"""
signals.lane_user_change.send(sender=self.user,
current=self,
old_lane=self.old_lane,
... |
def _update_task(self, task):
"""
Assigns current task step to self.task
then updates the task's data with self.task_data
Args:
task: Task object.
"""
self.task = task
self.task.data.update(self.task_data)
self.task_type = task.task_spec.__cla... |
def set_client_cmds(self):
"""
This is method automatically called on each request and
updates "object_id", "cmd" and "flow" client variables
from current.input.
"flow" and "object_id" variables will always exists in the
task_data so app developers can safely check for ... |
def generate_move(self, position):
"""
Returns valid and legal move given position
:type: position: Board
:rtype: Move
"""
while True:
print(position)
raw = input(str(self.color) + "\'s move \n")
move = converter.short_alg(raw, self.co... |
def in_check_as_result(self, pos, move):
"""
Finds if playing my move would make both kings meet.
:type: pos: Board
:type: move: Move
:rtype: bool
"""
test = cp(pos)
test.update(move)
test_king = test.get_king(move.color)
return self.loc_... |
def loc_adjacent_to_opponent_king(self, location, position):
"""
Finds if 2 kings are touching given the position of one of the kings.
:type: location: Location
:type: position: Board
:rtype: bool
"""
for fn in self.cardinal_directions:
try:
... |
def add(self, func, position):
"""
Adds all 8 cardinal directions as moves for the King if legal.
:type: function: function
:type: position: Board
:rtype: gen
"""
try:
if self.loc_adjacent_to_opponent_king(func(self.location), position):
... |
def _rook_legal_for_castle(self, rook):
"""
Decides if given rook exists, is of this color, and has not moved so it
is eligible to castle.
:type: rook: Rook
:rtype: bool
"""
return rook is not None and \
type(rook) is Rook and \
rook.color... |
def _empty_not_in_check(self, position, direction):
"""
Checks if set of squares in between ``King`` and ``Rook`` are empty and safe
for the king to castle.
:type: position: Position
:type: direction: function
:type: times: int
:rtype: bool
"""
de... |
def add_castle(self, position):
"""
Adds kingside and queenside castling moves if legal
:type: position: Board
"""
if self.has_moved or self.in_check(position):
return
if self.color == color.white:
rook_rank = 0
else:
rook_ran... |
def possible_moves(self, position):
"""
Generates list of possible moves
:type: position: Board
:rtype: list
"""
# Chain used to combine multiple generators
for move in itertools.chain(*[self.add(fn, position) for fn in self.cardinal_directions]):
yie... |
def in_check(self, position, location=None):
"""
Finds if the king is in check or if both kings are touching.
:type: position: Board
:return: bool
"""
location = location or self.location
for piece in position:
if piece is not None and piece.color !=... |
def set_keep_alive(sock, idle=10, interval=5, fails=5):
"""Sets the keep-alive setting for the peer socket.
:param sock: Socket to be configured.
:param idle: Interval in seconds after which for an idle connection a keep-alive probes
is start being sent.
:param interval: Interval in seconds betwe... |
def init_default(cls):
"""
Creates a ``Board`` with the standard chess starting position.
:rtype: Board
"""
return cls([
# First rank
[Rook(white, Location(0, 0)), Knight(white, Location(0, 1)), Bishop(white, Location(0, 2)),
Queen(white, Lo... |
def material_advantage(self, input_color, val_scheme):
"""
Finds the advantage a particular side possesses given a value scheme.
:type: input_color: Color
:type: val_scheme: PieceValues
:rtype: double
"""
if self.get_king(input_color).in_check(self) and self.no_... |
def advantage_as_result(self, move, val_scheme):
"""
Calculates advantage after move is played
:type: move: Move
:type: val_scheme: PieceValues
:rtype: double
"""
test_board = cp(self)
test_board.update(move)
return test_board.material_advantage(m... |
def all_possible_moves(self, input_color):
"""
Checks if all the possible moves has already been calculated
and is stored in `possible_moves` dictionary. If not, it is calculated
with `_calc_all_possible_moves`.
:type: input_color: Color
:rtype: list
"""
... |
def _calc_all_possible_moves(self, input_color):
"""
Returns list of all possible moves
:type: input_color: Color
:rtype: list
"""
for piece in self:
# Tests if square on the board is not empty
if piece is not None and piece.color == input_color:... |
def runInParallel(*fns):
"""
Runs multiple processes in parallel.
:type: fns: def
"""
proc = []
for fn in fns:
p = Process(target=fn)
p.start()
proc.append(p)
for p in proc:
p.join() |
def find_piece(self, piece):
"""
Finds Location of the first piece that matches piece.
If none is found, Exception is raised.
:type: piece: Piece
:rtype: Location
"""
for i, _ in enumerate(self.position):
for j, _ in enumerate(self.position):
... |
def get_piece(self, piece_type, input_color):
"""
Gets location of a piece on the board given the type and color.
:type: piece_type: Piece
:type: input_color: Color
:rtype: Location
"""
for loc in self:
piece = self.piece_at_square(loc)
... |
def place_piece_at_square(self, piece, location):
"""
Places piece at given get_location
:type: piece: Piece
:type: location: Location
"""
self.position[location.rank][location.file] = piece
piece.location = location |
def move_piece(self, initial, final):
"""
Moves piece from one location to another
:type: initial: Location
:type: final: Location
"""
self.place_piece_at_square(self.piece_at_square(initial), final)
self.remove_piece_at_square(initial) |
def update(self, move):
"""
Updates position by applying selected move
:type: move: Move
"""
if move is None:
raise TypeError("Move cannot be type None")
if self.king_loc_dict is not None and isinstance(move.piece, King):
self.king_loc_dict[move.... |
def _balance(self, ):
""" calc unbalanced charges and radicals for skin atoms
"""
meta = h.meta
for n in (skin_reagent.keys() | skin_product.keys()):
lost = skin_reagent[n]
cycle_lost = cycle(lost)
new = skin_product[n]
cycle_new = cycle(ne... |
def clone_subgraphs(self, g):
if not isinstance(g, CGRContainer):
raise InvalidData('only CGRContainer acceptable')
r_group = []
x_group = {}
r_group_clones = []
newcomponents = []
''' search bond breaks and creations
'''
components, lost_bon... |
def __get_substitution_paths(g):
"""
get atoms paths from detached atom to attached
:param g: CGRContainer
:return: tuple of atoms numbers
"""
for n, nbrdict in g.adjacency():
for m, l in combinations(nbrdict, 2):
nms = nbrdict[m]['sp_bond']
... |
def versions(self):
""" Read versions from the table
The versions are kept in cache for the next reads.
"""
if self._versions is None:
with self.database.cursor_autocommit() as cursor:
query = """
SELECT number,
date_sta... |
def simple_crud():
"""
Prepares menu entries for auto-generated model CRUD views.
This is simple version of :attr:`get_crud_menus()` without
Category support and permission control.
Just for development purposes.
Returns:
Dict of list of dicts (``{'':[{}],}``... |
def get_crud_menus(self):
"""
Generates menu entries according to
:attr:`zengine.settings.OBJECT_MENU` and permissions
of current user.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
for object_t... |
def _add_crud(self, model_data, object_type, results):
"""
Creates a menu entry for given model data.
Updates results in place.
Args:
model_data: Model data.
object_type: Relation name.
results: Results dict.
"""
model = model_registry... |
def _add_to_quick_menu(self, key, wf):
"""
Appends menu entries to dashboard quickmenu according
to :attr:`zengine.settings.QUICK_MENU`
Args:
key: workflow name
wf: workflow menu entry
"""
if key in settings.QUICK_MENU:
self.output['qu... |
def _get_workflow_menus(self):
"""
Creates menu entries for custom workflows.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
from zengine.lib.cache import WFSpecNames
for name, title, category in WFSpecN... |
def process_response(self, request, response, resource):
"""
Do response processing
"""
origin = request.get_header('Origin')
if not settings.DEBUG:
if origin in settings.ALLOWED_ORIGINS or not origin:
response.set_header('Access-Control-Allow-Origin',... |
def process_request(self, req, resp):
"""
Do response processing
"""
if not req.client_accepts_json:
raise falcon.HTTPNotAcceptable(
'This API only supports responses encoded as JSON.',
href='http://docs.examples.com/api/json')
if req.m... |
def process_request(self, req, resp):
"""
Do response processing
"""
# req.stream corresponds to the WSGI wsgi.input environ variable,
# and allows you to read bytes from the request body.
#
# See also: PEP 3333
if req.content_length in (None, 0):
... |
def process_response(self, req, resp, resource):
"""
Serializes ``req.context['result']`` to resp.body as JSON.
If :attr:`~zengine.settings.DEBUG` is True,
``sys._debug_db_queries`` (set by pyoko) added to response.
"""
if 'result' not in req.context:
return... |
def connect(self):
"""
Creates connection to RabbitMQ server
"""
if self.connecting:
log.info('PikaClient: Already connecting to RabbitMQ')
return
log.info('PikaClient: Connecting to RabbitMQ')
self.connecting = True
self.connection = Tor... |
def on_connected(self, connection):
"""
AMQP connection callback.
Creates input channel.
Args:
connection: AMQP connection
"""
log.info('PikaClient: connected to RabbitMQ')
self.connected = True
self.in_channel = self.connection.channel(self.o... |
def on_channel_open(self, channel):
"""
Input channel creation callback
Queue declaration done here
Args:
channel: input channel
"""
self.in_channel.exchange_declare(exchange='input_exc', type='topic', durable=True)
channel.queue_declare(callback=self... |
def on_input_queue_declare(self, queue):
"""
Input queue declaration callback.
Input Queue/Exchange binding done here
Args:
queue: input queue
"""
self.in_channel.queue_bind(callback=None,
exchange='input_exc',
... |
def wsgi_app(self, request):
"""Incoming request handler.
:param request: Werkzeug request object
"""
try:
if request.method != 'POST':
abort(400)
try:
# Python 2.7 compatibility
data = request.data
... |
def close(self, force=False):
"""
close opened file
:param force: force closing of externally opened file or buffer
"""
if self.__write:
self.write = self.__write_adhoc
self.__write = False
if not self._is_buffer or force:
self._file.... |
def _convert_reaction(self, reaction):
if not (reaction['reactants'] or reaction['products'] or reaction['reagents']):
raise ValueError('empty reaction')
maps = {'reactants': [], 'products': [], 'reagents': []}
for i, tmp in maps.items():
for molecule in reaction[i]:
... |
def aromatize(self):
"""
convert structure to aromatic form
:return: number of processed rings
"""
rings = [x for x in self.sssr if 4 < len(x) < 7]
if not rings:
return 0
total = 0
while True:
c = self._quinonize(rings, 'order')
... |
def crawl_cmd(self, seed_list, n):
'''
Runs the crawl job for n rounds
:param seed_list: lines of seed URLs
:param n: number of rounds
:return: number of successful rounds
'''
print("Num Rounds "+str(n))
cc = self.proxy.Crawl(seed=seed_list, rounds=n)
... |
def load_xml_conf(self, xml_file, id):
'''
Creates a new config from xml file.
:param xml_file: path to xml file. Format : nutch-site.xml or nutch-default.xml
:param id:
:return: config object
'''
# converting nutch-site.xml to key:value pairs
import xml.... |
def create_cmd(self, args):
'''
'create' sub-command
:param args: cli arguments
:return:
'''
cmd = args.get('cmd_create')
if cmd == 'conf':
conf_file = args['conf_file']
conf_id = args['id']
return self.load_xml_conf(conf_file, ... |
def close(self, *args, **kwargs):
"""
write close tag of MRV file and close opened file
:param force: force closing of externally opened file or buffer
"""
if not self.__finalized:
self._file.write('</cml>')
self.__finalized = True
super().close(*... |
def write(self, data):
"""
write single molecule or reaction into file
"""
self._file.write('<cml>')
self.__write(data)
self.write = self.__write |
def _load_cache(self):
"""
the method is implemented for the purpose of optimization, byte positions will not be re-read from a file
that has already been used, if the content of the file has changed, and the name has been left the same,
the old version of byte offsets will be loaded
... |
def _dump_cache(self, _shifts):
"""
_shifts dumps in /tmp directory after reboot it will drop
"""
with open(self.__cache_path, 'wb') as f:
dump(_shifts, f) |
def get_task_types(current):
"""
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_types',
}
# response:
{
'task_types':... |
def get_task_detail(current):
"""
Show task details
.. code-block:: python
# request:
{
'view': '_zops_get_task_detail',
'key': key,
}
# response:
{
... |
def get_task_actions(current):
"""
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_actions',
'key': key,
}
# response:
... |
def get_tasks(current):
"""
List task invitations of current user
.. code-block:: python
# request:
{
'view': '_zops_get_tasks',
'state': string, # one of these:
# "active", "future", "finished", "expire... |
def reduce_memory_usage(df):
"""reduce memory usage of the dataframe
- convert runIDs to categorical
- downcast ints and floats
"""
usage_pre = df.memory_usage(deep=True).sum()
if "runIDs" in df:
df.loc[:, "runIDs"] = df.loc[:, "runIDs"].astype("category")
df_int = df.select_dtypes(... |
def check_existance(f):
"""Check if the file supplied as input exists."""
if not opath.isfile(f):
logging.error("Nanoget: File provided doesn't exist or the path is incorrect: {}".format(f))
sys.exit("File provided doesn't exist or the path is incorrect: {}".format(f)) |
def list_user_roles(self):
"""
Lists user roles as selectable except user's current role.
"""
_form = JsonForm(current=self.current, title=_(u"Switch Role"))
_form.help_text = "Your current role: %s %s" % (self.current.role.unit.name,
... |
def change_user_role(self):
"""
Changes user's role from current role to chosen role.
"""
# Get chosen role_key from user form.
role_key = self.input['form']['role_options']
# Assign chosen switch role key to user's last_login_role_key field
self.current.user.las... |
def get_user_switchable_roles(self):
"""
Returns user's role list except current role as a tuple
(role.key, role.name)
Returns:
(list): list of tuples, user's role list except current role
"""
roles = []
for rs in self.current.user.role_set:
... |
def put_object(self, obj):
# TODO consider putting into a ES class
self.pr_dbg('put_obj: %s' % self.json_dumps(obj))
"""
Wrapper for es.index, determines metadata needed to index from obj.
If you have a raw object json string you can hard code these:
index is .kibana (as ... |
def del_object(self, obj):
"""Debug deletes obj of obj[_type] with id of obj['_id']"""
if obj['_index'] is None or obj['_index'] == "":
raise Exception("Invalid Object")
if obj['_id'] is None or obj['_id'] == "":
raise Exception("Invalid Object")
if obj['_type'] i... |
def json_dumps(self, obj):
"""Serializer for consistency"""
return json.dumps(obj, sort_keys=True, indent=4, separators=(',', ': ')) |
def safe_filename(self, otype, oid):
"""Santize obj name into fname and verify doesn't already exist"""
permitted = set(['_', '-', '(', ')'])
oid = ''.join([c for c in oid if c.isalnum() or c in permitted])
while oid.find('--') != -1:
oid = oid.replace('--', '-')
ext ... |
def write_object_to_file(self, obj, path='.', filename=None):
"""Convert obj (dict) to json string and write to file"""
output = self.json_dumps(obj) + '\n'
if filename is None:
filename = self.safe_filename(obj['_type'], obj['_id'])
filename = os.path.join(path, filename)
... |
def write_pkg_to_file(self, name, objects, path='.', filename=None):
"""Write a list of related objs to file"""
# Kibana uses an array of docs, do the same
# as opposed to a dict of docs
pkg_objs = []
for _, obj in iteritems(objects):
pkg_objs.append(obj)
sort... |
def get_objects(self, search_field, search_val):
"""Return all objects of type (assumes < MAX_HITS)"""
query = ("{ size: " + str(self.max_hits) + ", " +
"query: { filtered: { filter: { " +
search_field + ": { value: \"" + search_val + "\"" +
" } } } } }... |
def get_dashboard_full(self, db_name):
"""Get DB and all objs needed to duplicate it"""
objects = {}
dashboards = self.get_objects("type", "dashboard")
vizs = self.get_objects("type", "visualization")
searches = self.get_objects("type", "search")
if db_name not in dashboa... |
def parse_node(self, node):
"""
Overrides ProcessParser.parse_node
Parses and attaches the inputOutput tags that created by Camunda Modeller
Args:
node: xml task node
Returns:
TaskSpec
"""
spec = super(CamundaProcessParser, self).parse_no... |
def _get_description(self):
"""
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns:
"""
ns = {'ns': '{%s}' % BPMN_MODEL_NS}
desc = (
self.doc_xpath('.//{ns}collaboration/{ns}documentation'.format(**ns)) or
self.... |
def get_name(self):
"""
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
"""
ns = {'ns': '{%s}' % BPMN_MODEL_NS}
for path in ('.//{ns}process',
'.//{ns}collaboration',
'./... |
def _parse_input_data(self, node):
"""
Parses inputOutput part camunda modeller extensions.
Args:
node: SpiffWorkflow Node object.
Returns:
Data dict.
"""
data = DotDict()
try:
for nod in self._get_input_nodes(node):
... |
def _get_lane_properties(self, node):
"""
Parses the given XML node
Args:
node (xml): XML node.
.. code-block:: xml
<bpmn2:lane id="Lane_8" name="Lane 8">
<bpmn2:extensionElements>
<camunda:properties>
... |
def _parse_input_node(cls, node):
"""
:param node: xml node
:return: dict
"""
data = {}
child = node.getchildren()
if not child and node.get('name'):
val = node.text
elif child: # if tag = "{http://activiti.org/bpmn}script" then data_typ = 'sc... |
def package_in_memory(cls, workflow_name, workflow_files):
"""
Generates wf packages from workflow diagrams.
Args:
workflow_name: Name of wf
workflow_files: Diagram file.
Returns:
Workflow package (file like) object
"""
s = StringIO... |
def compose(self, data):
"""
condense reaction container to CGR. see init for details about cgr_type
:param data: ReactionContainer
:return: CGRContainer
"""
g = self.__separate(data) if self.__cgr_type in (1, 2, 3, 4, 5, 6) else self.__condense(data)
g.meta.upda... |
def add_atom(self, atom, _map=None):
"""
new atom addition
"""
if _map is None:
_map = max(self, default=0) + 1
elif _map in self._node:
raise KeyError('atom with same number exists')
attr_dict = self.node_attr_dict_factory()
if isinstance... |
def add_bond(self, atom1, atom2, bond):
"""
implementation of bond addition
"""
if atom1 == atom2:
raise KeyError('atom loops impossible')
if atom1 not in self._node or atom2 not in self._node:
raise KeyError('atoms not found')
if atom1 in self._ad... |
def delete_bond(self, n, m):
"""
implementation of bond removing
"""
self.remove_edge(n, m)
self.flush_cache() |
def environment(self, atom):
"""
pairs of (bond, atom) connected to atom
:param atom: number
:return: list
"""
return tuple((bond, self._node[n]) for n, bond in self._adj[atom].items()) |
def substructure(self, atoms, meta=False, as_view=True):
"""
create substructure containing atoms from nbunch list
:param atoms: list of atoms numbers of substructure
:param meta: if True metadata will be copied to substructure
:param as_view: If True, the returned graph-view pr... |
def augmented_substructure(self, atoms, dante=False, deep=1, meta=False, as_view=True):
"""
create substructure containing atoms and their neighbors
:param atoms: list of core atoms in graph
:param dante: if True return list of graphs containing atoms, atoms + first circle, atoms + 1st ... |
def split(self, meta=False):
"""
split disconnected structure to connected substructures
:param meta: copy metadata to each substructure
:return: list of substructures
"""
return [self.substructure(c, meta, False) for c in connected_components(self)] |
def bonds(self):
"""
iterate other all bonds
"""
seen = set()
for n, m_bond in self._adj.items():
seen.add(n)
for m, bond in m_bond.items():
if m not in seen:
yield n, m, bond |
def _get_subclass(name):
"""
need for cyclic import solving
"""
return next(x for x in BaseContainer.__subclasses__() if x.__name__ == name) |
def _default_make_pool(http, proxy_info):
"""Creates a urllib3.PoolManager object that has SSL verification enabled
and uses the certifi certificates."""
if not http.ca_certs:
http.ca_certs = _certifi_where_for_ssl_version()
ssl_disabled = http.disable_ssl_certificate_validation
cert_reqs... |
def patch(make_pool=_default_make_pool):
"""Monkey-patches httplib2.Http to be httplib2shim.Http.
This effectively makes all clients of httplib2 use urlilb3. It's preferable
to specify httplib2shim.Http explicitly where you can, but this can be
useful in situations where you do not control the construc... |
def _is_ipv6(addr):
"""Checks if a given address is an IPv6 address."""
try:
socket.inet_pton(socket.AF_INET6, addr)
return True
except socket.error:
return False |
def _certifi_where_for_ssl_version():
"""Gets the right location for certifi certifications for the current SSL
version.
Older versions of SSL don't support the stronger set of root certificates.
"""
if not ssl:
return
if ssl.OPENSSL_VERSION_INFO < (1, 0, 2):
warnings.warn(
... |
def _map_response(response, decode=False):
"""Maps a urllib3 response to a httplib/httplib2 Response."""
# This causes weird deepcopy errors, so it's commented out for now.
# item._urllib3_response = response
item = httplib2.Response(response.getheaders())
item.status = response.status
item['sta... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.