text stringlengths 81 112k |
|---|
在指定元素上执行alt组合事件
@note: key event -> alt + key
@param key: 如'X'
def Alt(cls, key):
""" 在指定元素上执行alt组合事件
@note: key event -> alt + key
@param key: 如'X'
"""
element = cls._element()
element.send_keys(Keys.ALT, key) |
在指定输入框发送 Null， 用于设置焦点
@note: key event -> NULL
def Focus(cls):
""" 在指定输入框发送 Null， 用于设置焦点
@note: key event -> NULL
"""
element = cls._element()
# element.send_keys(Keys.NULL)
action = ActionChains(Web.driver)
action.send_keys_to_element(element, Keys.NULL)
action.perform() |
文件上传， 非原生input
@todo: some upload.exe not prepared
@param file: 文件名(文件必须存在在工程resource目录下), upload.exe工具放在工程tools目录下
def Upload(cls, filename):
""" 文件上传， 非原生input
@todo: some upload.exe not prepared
@param file: 文件名(文件必须存在在工程resource目录下), upload.exe工具放在工程tools目录下
"""
raise Exception("to do")
TOOLS_PATH = ""
RESOURCE_PATH = ""
tool_4path = os.path.join(TOOLS_PATH, "upload.exe")
file_4path = os.path.join(RESOURCE_PATH, filename)
#file_4path.decode('utf-8').encode('gbk')
if os.path.isfile(file_4path):
cls.Click()
os.system(tool_4path + ' ' + file_4path)
else:
raise Exception('%s is not exists' % file_4path) |
上传， 一般，上传页面如果是input,原生file文件框, 如： <input type="file" id="test-image-file" name="test" accept="image/gif">，像这样的，定位到该元素，然后使用 send_keys 上传的文件的绝对路径
@param file_name: 文件名(文件必须存在在工程resource目录下)
def UploadType(cls, file_path):
""" 上传， 一般，上传页面如果是input,原生file文件框, 如： <input type="file" id="test-image-file" name="test" accept="image/gif">，像这样的，定位到该元素，然后使用 send_keys 上传的文件的绝对路径
@param file_name: 文件名(文件必须存在在工程resource目录下)
"""
if not os.path.isabs(file_path):
return False
if os.path.isfile(file_path):
cls.SendKeys(file_path)
else:
return False |
Updates the Dict with the given values. Turns internal dicts into Dicts.
def update(xCqNck7t, **kwargs):
"""Updates the Dict with the given values. Turns internal dicts into Dicts."""
def dict_list_val(inlist):
l = []
for i in inlist:
if type(i)==dict:
l.append(Dict(**i))
elif type(i)==list:
l.append(make_list(i))
elif type(i)==bytes:
l.append(i.decode('UTF-8'))
else:
l.append(i)
return l
for k in list(kwargs.keys()):
if type(kwargs[k])==dict:
xCqNck7t[k] = Dict(**kwargs[k])
elif type(kwargs[k])==list:
xCqNck7t[k] = dict_list_val(kwargs[k])
else:
xCqNck7t[k] = kwargs[k] |
sort the keys before returning them
def keys(self, key=None, reverse=False):
"""sort the keys before returning them"""
ks = sorted(list(dict.keys(self)), key=key, reverse=reverse)
return ks |
java -jar selenium-server.jar -role hub -port 4444
@param port: listen port of selenium hub
def hub(self, port):
''' java -jar selenium-server.jar -role hub -port 4444
@param port: listen port of selenium hub
'''
self._ip = "localhost"
self._port = port
self.command = [self._conf["java_path"], "-jar", self._conf["jar_path"], "-port", str(port), "-role", "hub"]
return self |
java -jar selenium-server.jar -role node -port 5555 -hub http://127.0.0.1:4444/grid/register/
@param port: listen port of selenium node
@param hub_address: hub address which node will connect to
def node(self,port, hub_address=("localhost", 4444)):
''' java -jar selenium-server.jar -role node -port 5555 -hub http://127.0.0.1:4444/grid/register/
@param port: listen port of selenium node
@param hub_address: hub address which node will connect to
'''
self._ip, self._port = hub_address
self.command = [self._conf["java_path"], "-jar", self._conf["jar_path"], "-port", str(port), "-role", "node", "-hub", "http://%s:%s/grid/register/" %(self._ip, self._port)]
return self |
start the selenium Remote Server.
def start_server(self):
"""start the selenium Remote Server."""
self.__subp = subprocess.Popen(self.command)
#print("\tselenium jar pid[%s] is running." %self.__subp.pid)
time.sleep(2) |
Determine whether hub server is running
:return:True or False
def is_runnnig(self):
"""Determine whether hub server is running
:return:True or False
"""
resp = None
try:
resp = requests.get("http://%s:%s" %(self._ip, self._port))
if resp.status_code == 200:
return True
else:
return False
except:
return False |
Implements two's complement negation.
def negate_gate(wordlen, input='x', output='~x'):
"""Implements two's complement negation."""
neg = bitwise_negate(wordlen, input, "tmp")
inc = inc_gate(wordlen, "tmp", output)
return neg >> inc |
Return a circuit taking a wordlen bitvector where only k
valuations return True. Uses encoding from [1].
Note that this is equivalent to (~x < k).
- TODO: Add automated simplification so that the circuits
are equiv.
[1]: Chakraborty, Supratik, et al. "From Weighted to Unweighted Model
Counting." IJCAI. 2015.
def kmodels(wordlen: int, k: int, input=None, output=None):
"""Return a circuit taking a wordlen bitvector where only k
valuations return True. Uses encoding from [1].
Note that this is equivalent to (~x < k).
- TODO: Add automated simplification so that the circuits
are equiv.
[1]: Chakraborty, Supratik, et al. "From Weighted to Unweighted Model
Counting." IJCAI. 2015.
"""
assert 0 <= k < 2**wordlen
if output is None:
output = _fresh()
if input is None:
input = _fresh()
input_names = named_indexes(wordlen, input)
atoms = map(aiger.atom, input_names)
active = False
expr = aiger.atom(False)
for atom, bit in zip(atoms, encode_int(wordlen, k, signed=False)):
active |= bit
if not active: # Skip until first 1.
continue
expr = (expr | atom) if bit else (expr & atom)
return aigbv.AIGBV(
aig=expr.aig,
input_map=frozenset([(input, tuple(input_names))]),
output_map=frozenset([(output, (expr.output,))]),
) |
Recursively flattens a list.
:param lobj: List to flatten
:type lobj: list
:rtype: list
For example:
>>> import pmisc
>>> pmisc.flatten_list([1, [2, 3, [4, 5, 6]], 7])
[1, 2, 3, 4, 5, 6, 7]
def flatten_list(lobj):
"""
Recursively flattens a list.
:param lobj: List to flatten
:type lobj: list
:rtype: list
For example:
>>> import pmisc
>>> pmisc.flatten_list([1, [2, 3, [4, 5, 6]], 7])
[1, 2, 3, 4, 5, 6, 7]
"""
ret = []
for item in lobj:
if isinstance(item, list):
for sub_item in flatten_list(item):
ret.append(sub_item)
else:
ret.append(item)
return ret |
tuple of (username, password). if use_keyring is set to true the password will be queried from the local keyring instead of taken from the
configuration file.
def auth(self):
"""
tuple of (username, password). if use_keyring is set to true the password will be queried from the local keyring instead of taken from the
configuration file.
"""
username = self._settings["username"]
if not username:
raise ValueError("Username was not configured in %s" % CONFIG_FILE)
if self._settings["use_keyring"]:
password = self.keyring_get_password(username)
if not password:
self.keyring_set_password(username)
password = self.keyring_get_password(username)
else:
password = self._settings["password"]
return self._settings["username"], password |
load a configuration file. loads default config if file is not found
def load(self, file=CONFIG_FILE):
"""
load a configuration file. loads default config if file is not found
"""
if not os.path.exists(file):
print("Config file was not found under %s. Default file has been created" % CONFIG_FILE)
self._settings = yaml.load(DEFAULT_CONFIG, yaml.RoundTripLoader)
self.save(file)
sys.exit()
with open(file, 'r') as f:
self._settings = yaml.load(f, yaml.RoundTripLoader) |
Save configuration to provided path as a yaml file
def save(self, file=CONFIG_FILE):
"""
Save configuration to provided path as a yaml file
"""
os.makedirs(os.path.dirname(file), exist_ok=True)
with open(file, "w") as f:
yaml.dump(self._settings, f, Dumper=yaml.RoundTripDumper, width=float("inf")) |
opens a curses/picker based interface to select courses that should be downloaded.
def selection_dialog(self, courses):
"""
opens a curses/picker based interface to select courses that should be downloaded.
"""
selected = list(filter(lambda x: x.course.id in self._settings["selected_courses"], courses))
selection = Picker(
title="Select courses to download",
options=courses,
checked=selected).getSelected()
if selection:
self._settings["selected_courses"] = list(map(lambda x: x.course.id, selection))
self.save()
log.info("Updated course selection") |
Create the corresponding index. Will overwrite existing indexes of the same name.
def create(self):
"""Create the corresponding index. Will overwrite existing indexes of the same name."""
body = dict()
if self.mapping is not None:
body['mappings'] = self.mapping
if self.settings is not None:
body['settings'] = self.settings
else:
body['settings'] = self._default_settings()
self.instance.indices.create(self.index, body) |
Search the index with a query.
Can at most return 10'000 results from a search. If the search would yield more than 10'000 hits, only the first 10'000 are returned.
The default number of hits returned is 100.
def search(self, query=None, size=100, unpack=True):
"""Search the index with a query.
Can at most return 10'000 results from a search. If the search would yield more than 10'000 hits, only the first 10'000 are returned.
The default number of hits returned is 100.
"""
logging.info('Download all documents from index %s.', self.index)
if query is None:
query = self.match_all
results = list()
data = self.instance.search(index=self.index, doc_type=self.doc_type, body=query, size=size)
if unpack:
for items in data['hits']['hits']:
if '_source' in items:
results.append(items['_source'])
else:
results.append(items)
else:
results = data['hits']['hits']
return results |
Scan the index with the query.
Will return any number of results above 10'000. Important to note is, that
all the data is loaded into memory at once and returned. This works only with small
data sets. Use scroll otherwise which returns a generator to cycle through the resources
in set chunks.
:param query: The query used to scan the index. Default None will return the entire index.
:returns list of dicts: The list of dictionaries contains all the documents without metadata.
def scan_index(self, query: Union[Dict[str, str], None] = None) -> List[Dict[str, str]]:
"""Scan the index with the query.
Will return any number of results above 10'000. Important to note is, that
all the data is loaded into memory at once and returned. This works only with small
data sets. Use scroll otherwise which returns a generator to cycle through the resources
in set chunks.
:param query: The query used to scan the index. Default None will return the entire index.
:returns list of dicts: The list of dictionaries contains all the documents without metadata.
"""
if query is None:
query = self.match_all
logging.info('Download all documents from index %s with query %s.', self.index, query)
results = list()
data = scan(self.instance, index=self.index, doc_type=self.doc_type, query=query)
for items in data:
if '_source' in items:
results.append(items['_source'])
else:
results.append(items)
return results |
Scroll an index with the specified search query.
Works as a generator. Will yield `size` results per iteration until all hits are returned.
def scroll(self, query=None, scroll='5m', size=100, unpack=True):
"""Scroll an index with the specified search query.
Works as a generator. Will yield `size` results per iteration until all hits are returned.
"""
query = self.match_all if query is None else query
response = self.instance.search(index=self.index, doc_type=self.doc_type, body=query, size=size, scroll=scroll)
while len(response['hits']['hits']) > 0:
scroll_id = response['_scroll_id']
logging.debug(response)
if unpack:
yield [source['_source'] if '_source' in source else source for source in response['hits']['hits']]
else:
yield response['hits']['hits']
response = self.instance.scroll(scroll_id=scroll_id, scroll=scroll) |
Fetch document by _id.
Returns None if it is not found. (Will log a warning if not found as well. Should not be used
to search an id.)
def get(self, identifier):
"""Fetch document by _id.
Returns None if it is not found. (Will log a warning if not found as well. Should not be used
to search an id.)"""
logging.info('Download document with id ' + str(identifier) + '.')
try:
record = self.instance.get(index=self.index, doc_type=self.doc_type, id=identifier)
if '_source' in record:
return record['_source']
else:
return record
except NotFoundError:
return None |
Index a single document into the index.
def index_into(self, document, id) -> bool:
"""Index a single document into the index."""
try:
self.instance.index(index=self.index, doc_type=self.doc_type, body=json.dumps(document, ensure_ascii=False), id=id)
except RequestError as ex:
logging.error(ex)
return False
else:
return True |
Delete a document with id.
def delete(self, doc_id: str) -> bool:
"""Delete a document with id."""
try:
self.instance.delete(self.index, self.doc_type, doc_id)
except RequestError as ex:
logging.error(ex)
return False
else:
return True |
Partial update to a single document.
Uses the Update API with the specified partial document.
def update(self, doc: dict, doc_id: str):
"""Partial update to a single document.
Uses the Update API with the specified partial document.
"""
body = {
'doc': doc
}
self.instance.update(self.index, self.doc_type, doc_id, body=body) |
Uses painless script to update a document.
See documentation for more information.
def script_update(self, script: str, params: Union[dict, None], doc_id: str):
"""Uses painless script to update a document.
See documentation for more information.
"""
body = {
'script': {
'source': script,
'lang': 'painless'
}
}
if params is not None:
body['script']['params'] = params
self.instance.update(self.index, self.doc_type, doc_id, body=body) |
Takes a list of dictionaries and an identifier key and indexes everything into this index.
:param data: List of dictionaries containing the data to be indexed.
:param identifier_key: The name of the dictionary element which should be used as _id. This will be removed from
the body. Is ignored when None or empty string. This will cause elastic
to create their own _id.
:param op_type: What should be done: 'index', 'delete', 'update'.
:param upsert: The update op_type can be upserted, which will create a document if not already present.
:param keep_id_key Determines if the value designated as the identifier_key should be kept
as part of the document or removed from it.
:returns Returns True if all the messages were indexed without errors. False otherwise.
def bulk(self, data: List[Dict[str, str]], identifier_key: str, op_type='index', upsert=False, keep_id_key=False) -> bool:
"""
Takes a list of dictionaries and an identifier key and indexes everything into this index.
:param data: List of dictionaries containing the data to be indexed.
:param identifier_key: The name of the dictionary element which should be used as _id. This will be removed from
the body. Is ignored when None or empty string. This will cause elastic
to create their own _id.
:param op_type: What should be done: 'index', 'delete', 'update'.
:param upsert: The update op_type can be upserted, which will create a document if not already present.
:param keep_id_key Determines if the value designated as the identifier_key should be kept
as part of the document or removed from it.
:returns Returns True if all the messages were indexed without errors. False otherwise.
"""
bulk_objects = []
for document in data:
bulk_object = dict()
bulk_object['_op_type'] = op_type
if identifier_key is not None and identifier_key != '':
bulk_object['_id'] = document[identifier_key]
if not keep_id_key:
document.pop(identifier_key)
if bulk_object['_id'] == '':
bulk_object.pop('_id')
if op_type == 'index':
bulk_object['_source'] = document
elif op_type == 'update':
bulk_object['doc'] = document
if upsert:
bulk_object['doc_as_upsert'] = True
bulk_objects.append(bulk_object)
logging.debug(str(bulk_object))
logging.info('Start bulk index for ' + str(len(bulk_objects)) + ' objects.')
errors = bulk(self.instance, actions=bulk_objects, index=self.index, doc_type=self.doc_type,
raise_on_error=False)
logging.info(str(errors[0]) + ' documents were successfully indexed/updated/deleted.')
if errors[0] - len(bulk_objects) != 0:
logging.error(str(len(bulk_objects) - errors[0]) + ' documents could not be indexed/updated/deleted.')
for error in errors[1]:
logging.error(str(error))
return False
else:
logging.debug('Finished bulk %s.', op_type)
return True |
Reindex the entire index.
Scrolls the old index and bulk indexes all data into the new index.
:param new_index_name:
:param identifier_key:
:param kwargs: Overwrite ElasticIndex __init__ params.
:return:
def reindex(self, new_index_name: str, identifier_key: str, **kwargs) -> 'ElasticIndex':
"""Reindex the entire index.
Scrolls the old index and bulk indexes all data into the new index.
:param new_index_name:
:param identifier_key:
:param kwargs: Overwrite ElasticIndex __init__ params.
:return:
"""
if 'url' not in kwargs:
kwargs['url'] = self.url
if 'doc_type' not in kwargs:
kwargs['doc_type'] = self.doc_type
if 'mapping' not in kwargs:
kwargs['mapping'] = self.mapping
new_index = ElasticIndex(new_index_name, **kwargs)
for results in self.scroll(size=500):
new_index.bulk(results, identifier_key)
return new_index |
Dumps the entire index into a json file.
:param path: The path to directory where the dump should be stored.
:param file_name: Name of the file the dump should be stored in. If empty the index name is used.
:param kwargs: Keyword arguments for the json converter. (ex. indent=4, ensure_ascii=False)
def dump(self, path: str, file_name: str = "", **kwargs: dict):
"""
Dumps the entire index into a json file.
:param path: The path to directory where the dump should be stored.
:param file_name: Name of the file the dump should be stored in. If empty the index name is used.
:param kwargs: Keyword arguments for the json converter. (ex. indent=4, ensure_ascii=False)
"""
export = list()
for results in self.scroll():
export.extend(results)
if not path.endswith('/'):
path += '/'
if file_name == '':
file_name = self.index
if not file_name.endswith('.json'):
file_name += '.json'
store = path + file_name
with open(store, 'w') as fp:
json.dump(export, fp, **kwargs)
logging.info("Extracted %s records from the index %s and stored them in %s/%s.", len(export), self.index, path, file_name) |
parse command line options and either launch some configuration dialog or start an instance of _MainLoop as a daemon
def main():
"""
parse command line options and either launch some configuration dialog or start an instance of _MainLoop as a daemon
"""
(options, _) = _parse_args()
if options.change_password:
c.keyring_set_password(c["username"])
sys.exit(0)
if options.select:
courses = client.get_courses()
c.selection_dialog(courses)
c.save()
sys.exit(0)
if options.stop:
os.system("kill -2 `cat ~/.studdp/studdp.pid`")
sys.exit(0)
task = _MainLoop(options.daemonize, options.update_courses)
if options.daemonize:
log.info("daemonizing...")
with daemon.DaemonContext(working_directory=".", pidfile=PIDLockFile(PID_FILE)):
# we have to create a new logger in the daemon context
handler = logging.FileHandler(LOG_PATH)
handler.setFormatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s')
log.addHandler(handler)
task()
else:
task() |
Takes data and returns a signature
:arg dict signature_data: data to use to generate a signature
:returns: ``Result`` instance
def generate(self, signature_data):
"""Takes data and returns a signature
:arg dict signature_data: data to use to generate a signature
:returns: ``Result`` instance
"""
result = Result()
for rule in self.pipeline:
rule_name = rule.__class__.__name__
try:
if rule.predicate(signature_data, result):
rule.action(signature_data, result)
except Exception as exc:
if self.error_handler:
self.error_handler(
signature_data,
exc_info=sys.exc_info(),
extra={'rule': rule_name}
)
result.info(rule_name, 'Rule failed: %s', exc)
return result |
Helper function to expand (blast) str -> int map into str ->
bool map. This is used to send word level inputs to aiger.
def _blast(bvname2vals, name_map):
"""Helper function to expand (blast) str -> int map into str ->
bool map. This is used to send word level inputs to aiger."""
if len(name_map) == 0:
return dict()
return fn.merge(*(dict(zip(names, bvname2vals[bvname]))
for bvname, names in name_map)) |
Helper function to lift str -> bool maps used by aiger
to the word level. Dual of the `_blast` function.
def _unblast(name2vals, name_map):
"""Helper function to lift str -> bool maps used by aiger
to the word level. Dual of the `_blast` function."""
def _collect(names):
return tuple(name2vals[n] for n in names)
return {bvname: _collect(names) for bvname, names in name_map} |
Generates a logger instance from the singleton
def create_logger(self):
"""Generates a logger instance from the singleton"""
name = "bors"
if hasattr(self, "name"):
name = self.name
self.log = logging.getLogger(name)
try:
lvl = self.conf.get_log_level()
except AttributeError:
lvl = self.context.get("log_level", None)
self.log.setLevel(getattr(logging, lvl, logging.INFO)) |
gets class from name and data, sets base level attrs
defaults to facsimile.base.Facsimile
def get_cls(project_name, project_data):
"""
gets class from name and data, sets base level attrs
defaults to facsimile.base.Facsimile
"""
if project_name:
cls = getattr(facsimile.base, project_data.get('class', 'Facsimile'))
cls.name = project_name
else:
cls = facsimile.base.Facsimile
return cls |
Chech that the entered recaptcha data is correct
def check_recaptcha(view_func):
"""Chech that the entered recaptcha data is correct"""
@wraps(view_func)
def _wrapped_view(request, *args, **kwargs):
request.recaptcha_is_valid = None
if request.method == 'POST':
recaptcha_response = request.POST.get('g-recaptcha-response')
data = {
'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY,
'response': recaptcha_response
}
r = requests.post(
'https://www.google.com/recaptcha/api/siteverify',
data=data
)
result = r.json()
if result['success']:
request.recaptcha_is_valid = True
else:
request.recaptcha_is_valid = False
error_message = 'Invalid reCAPTCHA. Please try again. '
error_message += str(result['error-codes'])
print(error_message)
return view_func(request, *args, **kwargs)
return _wrapped_view |
Internal request method
def _request(self, url, method="GET", params=None, api_call=None):
"""Internal request method"""
method = method.lower()
params = params or {}
func = getattr(requests, method)
requests_args = {}
if method == "get" or method == "delete":
requests_args["params"] = params
else:
if params.get("json"):
requests_args["json"] = params.get("json")
if params.get("files"):
requests_args["files"] = params.get("files")
if params.get("data"):
requests_args["data"] = params.get("data")
try:
response = func(url, **requests_args)
except requests.RequestException as e:
raise SafecastPyError(str(e))
# greater than 304 (not modified) is an error
if response.status_code > 304:
if response.status_code == 401:
raise SafecastPyAuthError(response.json().get("error"))
if response.status_code in [422]:
raise SafecastPyError(response.json().get("errors"))
raise SafecastPyError(response.content, error_code=response.status_code)
try:
if response.status_code == 204:
content = response.content
else:
content = response.json()
except ValueError:
raise SafecastPyError(
"Response was not valid JSON. \
Unable to decode."
)
return content |
Return dict of response received from Safecast's API
:param endpoint: (required) Full url or Safecast API endpoint
(e.g. measurements/users)
:type endpoint: string
:param method: (optional) Method of accessing data, either
GET, POST, PUT or DELETE. (default GET)
:type method: string
:param params: (optional) Dict of parameters (if any) accepted
the by Safecast API endpoint you are trying to
access (default None)
:type params: dict or None
:rtype: dict
def request(self, endpoint, method="GET", params=None):
"""Return dict of response received from Safecast's API
:param endpoint: (required) Full url or Safecast API endpoint
(e.g. measurements/users)
:type endpoint: string
:param method: (optional) Method of accessing data, either
GET, POST, PUT or DELETE. (default GET)
:type method: string
:param params: (optional) Dict of parameters (if any) accepted
the by Safecast API endpoint you are trying to
access (default None)
:type params: dict or None
:rtype: dict
"""
# In case they want to pass a full Safecast URL
# i.e. https://api.safecast.org/measurements.json
if endpoint.startswith("http"):
url = endpoint
else:
url = "%s/%s.json" % (self.api_url, endpoint)
if method != "GET":
if self.api_key is None:
raise SafecastPyAuthError("Require an api_key")
url = url + "?api_key={0}".format(self.api_key)
content = self._request(url, method=method, params=params, api_call=url)
return content |
(Copied from implementation in
https://github.com/greenelab/adage-server/blob/master/adage/analyze/api.py)
Handle an incoming POST as a GET to work around URI length limitations
def post_list(self, request, **kwargs):
"""
(Copied from implementation in
https://github.com/greenelab/adage-server/blob/master/adage/analyze/api.py)
Handle an incoming POST as a GET to work around URI length limitations
"""
# The convert_post_to_VERB() technique is borrowed from
# resources.py in tastypie source. This helps us to convert the POST
# to a GET in the proper way internally.
request.method = 'GET' # override the incoming POST
dispatch_request = convert_post_to_VERB(request, 'GET')
return self.dispatch('list', dispatch_request, **kwargs) |
Execute the strategies on the given context
def execute(self, context):
"""Execute the strategies on the given context"""
for ware in self.middleware:
ware.premessage(context)
context = ware.bind(context)
ware.postmessage(context)
return context |
Perform cleanup! We're goin' down!!!
def shutdown(self):
"""Perform cleanup! We're goin' down!!!"""
for ware in self.middleware:
ware.preshutdown()
self._shutdown()
ware.postshutdown() |
Generates documentation for signature generation pipeline
def main(argv=None):
"""Generates documentation for signature generation pipeline"""
parser = argparse.ArgumentParser(description=DESCRIPTION)
parser.add_argument(
'pipeline',
help='Python dotted path to rules pipeline to document'
)
parser.add_argument('output', help='output file')
if argv is None:
args = parser.parse_args()
else:
args = parser.parse_args(argv)
print('Generating documentation for %s in %s...' % (args.pipeline, args.output))
rules = import_rules(args.pipeline)
with open(args.output, 'w') as fp:
fp.write('.. THIS IS AUTOGEMERATED USING:\n')
fp.write(' \n')
fp.write(' %s\n' % (' '.join(sys.argv)))
fp.write(' \n')
fp.write('Signature generation rules pipeline\n')
fp.write('===================================\n')
fp.write('\n')
fp.write('\n')
fp.write(
'This is the signature generation pipeline defined at ``%s``:\n' %
args.pipeline
)
fp.write('\n')
for i, rule in enumerate(rules):
li = '%s. ' % (i + 1)
fp.write('%s%s\n' % (
li,
indent(get_doc(rule), ' ' * len(li))
))
fp.write('\n') |
This function is called by the Django API to specify how this object
will be saved to the database.
def handle(self, *args, **options):
"""This function is called by the Django API to specify how this object
will be saved to the database.
"""
taxonomy_id = options['taxonomy_id']
# Remove leading and trailing blank characters in "common_name"
# and "scientific_name
common_name = options['common_name'].strip()
scientific_name = options['scientific_name'].strip()
if common_name and scientific_name:
# A 'slug' is a label for an object in django, which only contains
# letters, numbers, underscores, and hyphens, thus making it URL-
# usable. The slugify method in django takes any string and
# converts it to this format. For more information, see:
# http://stackoverflow.com/questions/427102/what-is-a-slug-in-django
slug = slugify(scientific_name)
logger.info("Slug generated: %s", slug)
# If organism exists, update with passed parameters
try:
org = Organism.objects.get(taxonomy_id=taxonomy_id)
org.common_name = common_name
org.scientific_name = scientific_name
org.slug = slug
# If organism doesn't exist, construct an organism object
# (see organisms/models.py).
except Organism.DoesNotExist:
org = Organism(taxonomy_id=taxonomy_id,
common_name=common_name,
scientific_name=scientific_name,
slug=slug
)
org.save() # Save to the database.
else:
# Report an error if the user did not fill out all fields.
logger.error(
"Failed to add or update organism. "
"Please check that all fields are filled correctly."
) |
Creates a window of given resolution.
:param resolution: the resolution of the windows as (width, height) in
pixels
:type resolution: tuple
:param pygame_flags: modify the creation of the window.
For further information see :ref:`creating_a_window`
:type pygame_flags: int
:param display_pos: determines the position on the desktop where the
window is created. In a multi monitor system this can be used to position
the window on a different monitor. E.g. the monitor to the right of the
main-monitor would be at position (1920, 0) if the main monitor has the
width 1920.
:type display_pos: tuple
:param interactive_mode: Will install a thread, that emptys the
event-queue every 100ms. This is neccessary to be able to use the
display() function in an interactive console on windows systems.
If interactive_mode is set, init() will return a reference to the
background thread. This thread has a stop() method which can be used to
cancel it. If you use ctrl+d or exit() within ipython, while the thread
is still running, ipython will become unusable, but not close.
:type interactive_mode: bool
:return: a reference to the display screen, or a reference to the background
thread if interactive_mode was set to true. In the second scenario you
can obtain a reference to the display surface via
pygame.display.get_surface()
:rtype: pygame.Surface
def init(resolution, pygame_flags=0, display_pos=(0, 0), interactive_mode=False):
"""Creates a window of given resolution.
:param resolution: the resolution of the windows as (width, height) in
pixels
:type resolution: tuple
:param pygame_flags: modify the creation of the window.
For further information see :ref:`creating_a_window`
:type pygame_flags: int
:param display_pos: determines the position on the desktop where the
window is created. In a multi monitor system this can be used to position
the window on a different monitor. E.g. the monitor to the right of the
main-monitor would be at position (1920, 0) if the main monitor has the
width 1920.
:type display_pos: tuple
:param interactive_mode: Will install a thread, that emptys the
event-queue every 100ms. This is neccessary to be able to use the
display() function in an interactive console on windows systems.
If interactive_mode is set, init() will return a reference to the
background thread. This thread has a stop() method which can be used to
cancel it. If you use ctrl+d or exit() within ipython, while the thread
is still running, ipython will become unusable, but not close.
:type interactive_mode: bool
:return: a reference to the display screen, or a reference to the background
thread if interactive_mode was set to true. In the second scenario you
can obtain a reference to the display surface via
pygame.display.get_surface()
:rtype: pygame.Surface
"""
os.environ['SDL_VIDEO_WINDOW_POS'] = "{}, {}".format(*display_pos)
pygame.init()
pygame.font.init()
disp = pygame.display.set_mode(resolution, pygame_flags)
return _PumpThread() if interactive_mode else disp |
Displays a pygame.Surface in the window.
in pygame the window is represented through a surface, on which you can draw
as on any other pygame.Surface. A refernce to to the screen can be optained
via the :py:func:`pygame.display.get_surface` function. To display the
contents of the screen surface in the window :py:func:`pygame.display.flip`
needs to be called.
:py:func:`display` draws the surface onto the screen surface at the postion
(0, 0), and then calls :py:func:`flip`.
:param surface: the pygame.Surface to display
:type surface: pygame.Surface
def display(surface):
"""Displays a pygame.Surface in the window.
in pygame the window is represented through a surface, on which you can draw
as on any other pygame.Surface. A refernce to to the screen can be optained
via the :py:func:`pygame.display.get_surface` function. To display the
contents of the screen surface in the window :py:func:`pygame.display.flip`
needs to be called.
:py:func:`display` draws the surface onto the screen surface at the postion
(0, 0), and then calls :py:func:`flip`.
:param surface: the pygame.Surface to display
:type surface: pygame.Surface
"""
screen = pygame.display.get_surface()
screen.blit(surface, (0, 0))
pygame.display.flip() |
Returns an empty surface filled with fill_color.
:param fill_color: color to fill the surface with
:type fill_color: pygame.Color
:param size: the size of the new surface, if None its created
to be the same size as the screen
:type size: int-2-tuple
def empty_surface(fill_color, size=None):
"""Returns an empty surface filled with fill_color.
:param fill_color: color to fill the surface with
:type fill_color: pygame.Color
:param size: the size of the new surface, if None its created
to be the same size as the screen
:type size: int-2-tuple
"""
sr = pygame.display.get_surface().get_rect()
surf = pygame.Surface(size or (sr.w, sr.h))
surf.fill(fill_color)
return surf |
This is a convinience method for use with
EventListener.wait_for_unicode_char(). In most cases it simply appends
char to buffer. Some replacements are done because presing return will
produce '\\r' but for most cases '\\n' would be desireable.
Also backspace cant just be added to a string either, therefore, if char is
"\\u0008" the last character from buffer will be cut off. The replacement
from '\\r' to '\\n' is done using the mappings argument, the default value
for it also contains a mapping from '\t' to 4 spaces.
:param buffer: the string to be updated
:type buffer: str
:param char: the unicode character to be processed
:type char: str
:param mappings: a dict containing mappings
:type mappings: dict
:returns: a new string
def process_char(buffer: str, char: str, mappings=_char_mappings):
"""This is a convinience method for use with
EventListener.wait_for_unicode_char(). In most cases it simply appends
char to buffer. Some replacements are done because presing return will
produce '\\r' but for most cases '\\n' would be desireable.
Also backspace cant just be added to a string either, therefore, if char is
"\\u0008" the last character from buffer will be cut off. The replacement
from '\\r' to '\\n' is done using the mappings argument, the default value
for it also contains a mapping from '\t' to 4 spaces.
:param buffer: the string to be updated
:type buffer: str
:param char: the unicode character to be processed
:type char: str
:param mappings: a dict containing mappings
:type mappings: dict
:returns: a new string"""
if char in mappings:
return buffer + mappings[char]
elif char == "\u0008":
return buffer[:-1] if len(buffer) > 0 else buffer
else:
return buffer + char |
Called by internal API subsystem to initialize websockets connections
in the API interface
def run(self):
"""
Called by internal API subsystem to initialize websockets connections
in the API interface
"""
self.api = self.context.get("cls")(self.context)
self.context["inst"].append(self) # Adapters used by strategies
def on_ws_connect(*args, **kwargs):
"""Callback on connect hook to set is_connected_ws"""
self.is_connected_ws = True
self.api.on_ws_connect(*args, **kwargs)
# Initialize websocket in a thread with channels
if hasattr(self.api, "on_ws_connect"):
self.thread = Process(target=self.api.connect_ws, args=(
on_ws_connect, [
SockChannel(channel, res_type, self._generate_result)
for channel, res_type in
self
.context
.get("conf")
.get("subscriptions")
.items()
]))
self.thread.start() |
Take a list of SockChannel objects and extend the websock listener
def add_channels(self, channels):
"""
Take a list of SockChannel objects and extend the websock listener
"""
chans = [
SockChannel(chan, res, self._generate_result)
for chan, res in channels.items()
]
self.api.channels.extend(chans)
self.api.connect_channels(chans) |
Generate the result object
def _generate_result(self, res_type, channel, result):
"""Generate the result object"""
schema = self.api.ws_result_schema()
schema.context['channel'] = channel
schema.context['response_type'] = res_type
self.callback(schema.load(result), self.context) |
returns a random element from seq n times. If n is None, it continues indefinitly
def rand_elem(seq, n=None):
"""returns a random element from seq n times. If n is None, it continues indefinitly"""
return map(random.choice, repeat(seq, n) if n is not None else repeat(seq)) |
Return first paragraph of multiline_str as a oneliner.
When without_trailing_dot is True, the last char of the first paragraph
will be removed, if it is a dot ('.').
Examples:
>>> multiline_str = 'first line\\nsecond line\\n\\nnext paragraph'
>>> print(first_paragraph(multiline_str))
first line second line
>>> multiline_str = 'first \\n second \\n \\n next paragraph '
>>> print(first_paragraph(multiline_str))
first second
>>> multiline_str = 'first line\\nsecond line\\n\\nnext paragraph'
>>> print(first_paragraph(multiline_str, maxlength=3))
fir
>>> multiline_str = 'first line\\nsecond line\\n\\nnext paragraph'
>>> print(first_paragraph(multiline_str, maxlength=78))
first line second line
>>> multiline_str = 'first line.'
>>> print(first_paragraph(multiline_str))
first line
>>> multiline_str = 'first line.'
>>> print(first_paragraph(multiline_str, without_trailing_dot=False))
first line.
>>> multiline_str = ''
>>> print(first_paragraph(multiline_str))
<BLANKLINE>
def first_paragraph(multiline_str, without_trailing_dot=True, maxlength=None):
'''Return first paragraph of multiline_str as a oneliner.
When without_trailing_dot is True, the last char of the first paragraph
will be removed, if it is a dot ('.').
Examples:
>>> multiline_str = 'first line\\nsecond line\\n\\nnext paragraph'
>>> print(first_paragraph(multiline_str))
first line second line
>>> multiline_str = 'first \\n second \\n \\n next paragraph '
>>> print(first_paragraph(multiline_str))
first second
>>> multiline_str = 'first line\\nsecond line\\n\\nnext paragraph'
>>> print(first_paragraph(multiline_str, maxlength=3))
fir
>>> multiline_str = 'first line\\nsecond line\\n\\nnext paragraph'
>>> print(first_paragraph(multiline_str, maxlength=78))
first line second line
>>> multiline_str = 'first line.'
>>> print(first_paragraph(multiline_str))
first line
>>> multiline_str = 'first line.'
>>> print(first_paragraph(multiline_str, without_trailing_dot=False))
first line.
>>> multiline_str = ''
>>> print(first_paragraph(multiline_str))
<BLANKLINE>
'''
stripped = '\n'.join([line.strip() for line in multiline_str.splitlines()])
paragraph = stripped.split('\n\n')[0]
res = paragraph.replace('\n', ' ')
if without_trailing_dot:
res = res.rsplit('.', 1)[0]
if maxlength:
res = res[0:maxlength]
return res |
Print the first paragraph of the docstring of the decorated function.
The paragraph will be printed as a oneliner.
May be invoked as a simple, argument-less decorator (i.e. ``@print_doc1``)
or with named arguments ``color``, ``bold``, ``prefix`` of ``tail``
(eg. ``@print_doc1(color=utils.red, bold=True, prefix=' ')``).
Examples:
# >>> @print_doc1
# ... def foo():
# ... """First line of docstring.
# ...
# ... another line.
# ... """
# ... pass
# ...
# >>> foo()
# \033[34mFirst line of docstring\033[0m
# >>> @print_doc1
# ... def foo():
# ... """First paragraph of docstring which contains more than one
# ... line.
# ...
# ... Another paragraph.
# ... """
# ... pass
# ...
# >>> foo()
# \033[34mFirst paragraph of docstring which contains more than one line\033[0m
def print_doc1(*args, **kwargs):
'''Print the first paragraph of the docstring of the decorated function.
The paragraph will be printed as a oneliner.
May be invoked as a simple, argument-less decorator (i.e. ``@print_doc1``)
or with named arguments ``color``, ``bold``, ``prefix`` of ``tail``
(eg. ``@print_doc1(color=utils.red, bold=True, prefix=' ')``).
Examples:
# >>> @print_doc1
# ... def foo():
# ... """First line of docstring.
# ...
# ... another line.
# ... """
# ... pass
# ...
# >>> foo()
# \033[34mFirst line of docstring\033[0m
# >>> @print_doc1
# ... def foo():
# ... """First paragraph of docstring which contains more than one
# ... line.
# ...
# ... Another paragraph.
# ... """
# ... pass
# ...
# >>> foo()
# \033[34mFirst paragraph of docstring which contains more than one line\033[0m
'''
# output settings from kwargs or take defaults
color = kwargs.get('color', blue)
bold = kwargs.get('bold', False)
prefix = kwargs.get('prefix', '')
tail = kwargs.get('tail', '\n')
def real_decorator(func):
'''real decorator function'''
@wraps(func)
def wrapper(*args, **kwargs):
'''the wrapper function'''
try:
prgf = first_paragraph(func.__doc__)
print(color(prefix + prgf + tail, bold))
except AttributeError as exc:
name = func.__name__
print(red(flo('{name}() has no docstring')))
raise(exc)
return func(*args, **kwargs)
return wrapper
invoked = bool(not args or kwargs)
if not invoked:
# invoke decorator function which returns the wrapper function
return real_decorator(func=args[0])
return real_decorator |
Decorator, print the full name of the decorated function.
May be invoked as a simple, argument-less decorator (i.e. ``@print_doc1``)
or with named arguments ``color``, ``bold``, or ``prefix``
(eg. ``@print_doc1(color=utils.red, bold=True, prefix=' ')``).
def print_full_name(*args, **kwargs):
'''Decorator, print the full name of the decorated function.
May be invoked as a simple, argument-less decorator (i.e. ``@print_doc1``)
or with named arguments ``color``, ``bold``, or ``prefix``
(eg. ``@print_doc1(color=utils.red, bold=True, prefix=' ')``).
'''
color = kwargs.get('color', default_color)
bold = kwargs.get('bold', False)
prefix = kwargs.get('prefix', '')
tail = kwargs.get('tail', '')
def real_decorator(func):
'''real decorator function'''
@wraps(func)
def wrapper(*args, **kwargs):
'''the wrapper function'''
first_line = ''
try:
first_line = func.__module__ + '.' + func.__qualname__
except AttributeError as exc:
first_line = func.__name__
print(color(prefix + first_line + tail, bold))
return func(*args, **kwargs)
return wrapper
invoked = bool(not args or kwargs)
if not invoked:
# invoke decorator function which returns the wrapper function
return real_decorator(func=args[0])
return real_decorator |
Return str template with applied substitutions.
Example:
>>> template = 'Asyl for {{name}} {{surname}}!'
>>> filled_out_template_str(template, name='Edward', surname='Snowden')
'Asyl for Edward Snowden!'
>>> template = '[[[foo]]] was substituted by {{foo}}'
>>> filled_out_template_str(template, foo='bar')
'{{foo}} was substituted by bar'
>>> template = 'names wrapped by {single} {curly} {braces} {{curly}}'
>>> filled_out_template_str(template, curly='remains unchanged')
'names wrapped by {single} {curly} {braces} remains unchanged'
def filled_out_template_str(template, **substitutions):
'''Return str template with applied substitutions.
Example:
>>> template = 'Asyl for {{name}} {{surname}}!'
>>> filled_out_template_str(template, name='Edward', surname='Snowden')
'Asyl for Edward Snowden!'
>>> template = '[[[foo]]] was substituted by {{foo}}'
>>> filled_out_template_str(template, foo='bar')
'{{foo}} was substituted by bar'
>>> template = 'names wrapped by {single} {curly} {braces} {{curly}}'
>>> filled_out_template_str(template, curly='remains unchanged')
'names wrapped by {single} {curly} {braces} remains unchanged'
'''
template = template.replace('{', '{{')
template = template.replace('}', '}}')
template = template.replace('{{{{', '{')
template = template.replace('}}}}', '}')
template = template.format(**substitutions)
template = template.replace('{{', '{')
template = template.replace('}}', '}')
template = template.replace('[[[', '{{')
template = template.replace(']]]', '}}')
return template |
Return content of file filename with applied substitutions.
def filled_out_template(filename, **substitutions):
'''Return content of file filename with applied substitutions.'''
res = None
with open(filename, 'r') as fp:
template = fp.read()
res = filled_out_template_str(template, **substitutions)
return res |
Search in file 'filename' for a line starting with 'prefix' and replace
the line by 'new_line'.
If a line starting with 'prefix' not exists 'new_line' will be appended.
If the file not exists, it will be created.
Return False if new_line was appended, else True (i.e. if the prefix was
found within of the file).
def update_or_append_line(filename, prefix, new_line, keep_backup=True,
append=True):
'''Search in file 'filename' for a line starting with 'prefix' and replace
the line by 'new_line'.
If a line starting with 'prefix' not exists 'new_line' will be appended.
If the file not exists, it will be created.
Return False if new_line was appended, else True (i.e. if the prefix was
found within of the file).
'''
same_line_exists, line_updated = False, False
filename = os.path.expanduser(filename)
if os.path.isfile(filename):
backup = filename + '~'
shutil.move(filename, backup)
# with open(filename, 'w') as dest, open(backup, 'r') as source:
with open(filename, 'w') as dest:
with open(backup, 'r') as source:
# try update..
for line in source:
if line == new_line:
same_line_exists = True
if line.startswith(prefix):
dest.write(new_line + '\n')
line_updated = True
else:
dest.write(line)
# ..or append
if not (same_line_exists or line_updated) and append:
dest.write(new_line + '\n')
if not keep_backup:
os.remove(backup)
else:
with open(filename, 'w') as dest:
dest.write(new_line + '\n')
return same_line_exists or line_updated |
Comment line out by putting a comment sign in front of the line.
If the file does not contain the line, the files content will not be
changed (but the file will be touched in every case).
def comment_out_line(filename, line, comment='#',
update_or_append_line=update_or_append_line):
'''Comment line out by putting a comment sign in front of the line.
If the file does not contain the line, the files content will not be
changed (but the file will be touched in every case).
'''
update_or_append_line(filename, prefix=line, new_line=comment+line,
append=False) |
Remove the comment of an commented out line and make the line "active".
If such an commented out line not exists it would be appended.
def uncomment_or_update_or_append_line(filename, prefix, new_line, comment='#',
keep_backup=True,
update_or_append_line=update_or_append_line):
'''Remove the comment of an commented out line and make the line "active".
If such an commented out line not exists it would be appended.
'''
uncommented = update_or_append_line(filename, prefix=comment+prefix,
new_line=new_line,
keep_backup=keep_backup, append=False)
if not uncommented:
update_or_append_line(filename, prefix, new_line,
keep_backup=keep_backup, append=True) |
Return a copy of `input` with every str component encoded from unicode to
utf-8.
def convert_unicode_2_utf8(input):
'''Return a copy of `input` with every str component encoded from unicode to
utf-8.
'''
if isinstance(input, dict):
try:
# python-2.6
return dict((convert_unicode_2_utf8(key), convert_unicode_2_utf8(value))
for key, value
in input.iteritems())
except AttributeError:
# since python-2.7 cf. http://stackoverflow.com/a/1747827
# [the ugly eval('...') is required for a valid syntax on
# python-2.6, cf. http://stackoverflow.com/a/25049535]
return eval('''{convert_unicode_2_utf8(key): convert_unicode_2_utf8(value)
for key, value
in input.items()}''')
elif isinstance(input, list):
return [convert_unicode_2_utf8(element) for element in input]
# elif order relevant: python2 vs. python3
# cf. http://stackoverflow.com/a/19877309
elif isinstance(input, str):
return input
else:
try:
if eval('''isinstance(input, unicode)'''):
return input.encode('utf-8')
except NameError:
# unicode does not exist in python-3.x
pass
return input |
Return the json-file data, with all strings utf-8 encoded.
def load_json(filename, gzip_mode=False):
'''Return the json-file data, with all strings utf-8 encoded.'''
open_file = open
if gzip_mode:
open_file = gzip.open
try:
with open_file(filename, 'rt') as fh:
data = json.load(fh)
data = convert_unicode_2_utf8(data)
return data
except AttributeError:
# Python-2.6
fh = open_file(filename, 'rt')
data = json.load(fh)
fh.close()
data = convert_unicode_2_utf8(data)
return data |
Write the python data structure as a json-Object to filename.
def write_json(data, filename, gzip_mode=False):
'''Write the python data structure as a json-Object to filename.'''
open_file = open
if gzip_mode:
open_file = gzip.open
try:
with open_file(filename, 'wt') as fh:
json.dump(obj=data, fp=fh, sort_keys=True)
except AttributeError:
# Python-2.6
fh = open_file(filename, 'wt')
json.dump(obj=data, fp=fh, sort_keys=True)
fh.close() |
Return text with a `newline` inserted after each `line_length` char.
Return `text` unchanged if line_length == 0.
def text_with_newlines(text, line_length=78, newline='\n'):
'''Return text with a `newline` inserted after each `line_length` char.
Return `text` unchanged if line_length == 0.
'''
if line_length > 0:
if len(text) <= line_length:
return text
else:
return newline.join([text[idx:idx+line_length]
for idx
in range(0, len(text), line_length)])
else:
return text |
A memoize decorator for class properties.
Return a cached property that is calculated by function `func` on first
access.
def lazy_val(func, with_del_hook=False):
'''A memoize decorator for class properties.
Return a cached property that is calculated by function `func` on first
access.
'''
def hook_for(that):
try:
orig_del = that.__del__
except AttributeError:
orig_del = None
def del_hook(*args, **kwargs):
del that._cache[id(that)]
del that._del_hook_cache[id(that)]
if orig_del is not None:
orig_del(that, *args, **kwargs)
try:
if orig_del is not None:
that.__del__ = del_hook
except AttributeError:
# that.__del__ is a class property and cannot be changed by instance
orig_del = None
return del_hook
def add_to_del_hook_cache(that):
if with_del_hook:
try:
that._del_hook_cache[id(that)] = hook_for(that)
except AttributeError:
# when that._del_hook_cache not exists, it means it is not a
# class property. Then, we don't need a del_hook().
pass
@functools.wraps(func)
def get(self):
try:
return self._cache[id(self)][func]
except AttributeError:
self._cache = {id(self): {}, }
add_to_del_hook_cache(self)
except KeyError:
try:
self._cache[id(self)]
except KeyError:
self._cache[id(self)] = {}
add_to_del_hook_cache(self)
val = self._cache[id(self)][func] = func(self)
return val
return property(get) |
Read all lines from file.
def _readlines(fname, fpointer1=open, fpointer2=open): # pragma: no cover
"""Read all lines from file."""
# fpointer1, fpointer2 arguments to ease testing
try:
with fpointer1(fname, "r") as fobj:
return fobj.readlines()
except UnicodeDecodeError: # pragma: no cover
with fpointer2(fname, "r", encoding="utf-8") as fobj:
return fobj.readlines() |
Generic interface to REST apiGeneric interface to REST api
:param callname: query name
:param data: dictionary of inputs
:param args: keyword arguments added to the payload
:return:
def call(self, callname, data=None, **args):
"""
Generic interface to REST apiGeneric interface to REST api
:param callname: query name
:param data: dictionary of inputs
:param args: keyword arguments added to the payload
:return:
"""
url = f"{self.url_base}/{callname}"
payload = self.payload.copy()
payload.update(**args)
if data is not None:
payload.update(data)
res = self.session.post(url, data=payload)
if res.status_code > 299:
self.log.error(f"URL: {url}")
self.log.error(f"Payload: {payload}")
self.log.error(f"STATUS: {res.status_code}")
self.log.error(f"RESPONSE: {res.text}")
return
elif 'error' in res.json():
self.log.error(res.json()['error'])
return
return res.json() |
launch nagios_plugin command
def launch_plugin(self):
'''
launch nagios_plugin command
'''
# nagios_plugins probes
for plugin in self.plugins:
# Construct the nagios_plugin command
command = ('%s%s' % (self.plugins[plugin]['path'], self.plugins[plugin]['command']))
try:
nagios_plugin = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
except OSError:
LOG.error("[nagios_plugins]: '%s' executable is missing",
command)
else:
output = nagios_plugin.communicate()[0].strip()
return_code = nagios_plugin.returncode
if return_code >= len(STATUSES):
LOG.error("[nagios_plugins]: '%s' executable has an issue, return code: %s",
command, return_code)
else:
LOG.log(STATUSES[return_code][1],
"[nagios_plugins][%s] (%s status): %s",
plugin,
STATUSES[return_code][0],
output)
yield {'return_code': int(return_code),
'output': str(output),
'time_stamp': int(time.time()),
'service_description': plugin,
'specific_servers': self.plugins[plugin]['servers']} |
for a given path and regexp pattern, return the files that match
def match(Class, path, pattern, flags=re.I, sortkey=None, ext=None):
"""for a given path and regexp pattern, return the files that match"""
return sorted(
[
Class(fn=fn)
for fn in rglob(path, f"*{ext or ''}")
if re.search(pattern, os.path.basename(fn), flags=flags) is not None
and os.path.basename(fn)[0] != '~' # omit temp files
],
key=sortkey,
) |
copy the file to the new_fn, preserving atime and mtime
def copy(self, new_fn):
"""copy the file to the new_fn, preserving atime and mtime"""
new_file = self.__class__(fn=str(new_fn))
new_file.write(data=self.read())
new_file.utime(self.atime, self.mtime)
return new_file |
make a filesystem-compliant basename for this file
def make_basename(self, fn=None, ext=None):
"""make a filesystem-compliant basename for this file"""
fb, oldext = os.path.splitext(os.path.basename(fn or self.fn))
ext = ext or oldext.lower()
fb = String(fb).hyphenify(ascii=True)
return ''.join([fb, ext]) |
write the contents of the file to a tempfile and return the tempfile filename
def tempfile(self, mode='wb', **args):
"write the contents of the file to a tempfile and return the tempfile filename"
tf = tempfile.NamedTemporaryFile(mode=mode)
self.write(tf.name, mode=mode, **args)
return tfn |
delete the file from the filesystem.
def delete(self):
"""delete the file from the filesystem."""
if self.isfile:
os.remove(self.fn)
elif self.isdir:
shutil.rmtree(self.fn) |
given a number of bytes, return the file size in readable units
def readable_size(C, bytes, suffix='B', decimals=1, sep='\u00a0'):
"""given a number of bytes, return the file size in readable units"""
if bytes is None:
return
size = float(bytes)
for unit in C.SIZE_UNITS:
if abs(size) < 1024 or unit == C.SIZE_UNITS[-1]:
return "{size:.{decimals}f}{sep}{unit}{suffix}".format(
size=size,
unit=unit,
suffix=suffix,
sep=sep,
decimals=C.SIZE_UNITS.index(unit) > 0 and decimals or 0, # B with no decimal
)
size /= 1024 |
given a readable_size (as produced by File.readable_size()), return the number of bytes.
def bytes_from_readable_size(C, size, suffix='B'):
"""given a readable_size (as produced by File.readable_size()), return the number of bytes."""
s = re.split("^([0-9\.]+)\s*([%s]?)%s?" % (''.join(C.SIZE_UNITS), suffix), size, flags=re.I)
bytes, unit = round(float(s[1])), s[2].upper()
while unit in C.SIZE_UNITS and C.SIZE_UNITS.index(unit) > 0:
bytes *= 1024
unit = C.SIZE_UNITS[C.SIZE_UNITS.index(unit) - 1]
return bytes |
Executed on startup of application
def run(self):
"""Executed on startup of application"""
for wsock in self.wsocks:
wsock.run()
for api in self.apis:
api.run() |
Executed on shutdown of application
def shutdown(self):
"""Executed on shutdown of application"""
for wsock in self.wsocks:
wsock.shutdown()
for api in self.apis:
api.shutdown() |
Makes a HTTP call, formats response and does error handling.
def request(self, url, method, data=None, headers=None):
"""Makes a HTTP call, formats response and does error handling.
"""
http_headers = merge_dict(self.default_headers, headers or {})
request_data = merge_dict({'api_key': self.apikey}, data or {})
logger.info('HTTP %s REQUEST TO %s' % (method, url))
start = datetime.datetime.now()
try:
response = requests.request(method=method, url=url, data=json.dumps(request_data),
headers=http_headers)
except exceptions.BadRequestError as e:
return json.loads({'errors': e.content})
duration = datetime.datetime.now() - start
logger.info('RESPONSE %s DURATION %s.%s' % (response.encoding, duration.seconds,
duration.microseconds))
return json.loads(response.content) if response.content else {} |
Makes a GET request
def get(self, action, params=None, headers=None):
"""Makes a GET request
"""
return self.request(make_url(self.endpoint, action), method='GET', data=params,
headers=headers) |
Makes a GET request
def post(self, action, data=None, headers=None):
"""Makes a GET request
"""
return self.request(make_url(self.endpoint, action), method='POST', data=data,
headers=headers) |
Makes a GET request
def delete(self, action, headers=None):
"""Makes a GET request
"""
return self.request(make_url(self.endpoint, action), method='DELETE',
headers=headers) |
Calculates a good piece size for a size
def calc_piece_size(size, min_piece_size=20, max_piece_size=29, max_piece_count=1000):
"""
Calculates a good piece size for a size
"""
logger.debug('Calculating piece size for %i' % size)
for i in range(min_piece_size, max_piece_size): # 20 = 1MB
if size / (2**i) < max_piece_count:
break
return 2**i |
Prepare a list of all pieces grouped together
def split_pieces(piece_list, segments, num):
"""
Prepare a list of all pieces grouped together
"""
piece_groups = []
pieces = list(piece_list)
while pieces:
for i in range(segments):
p = pieces[i::segments][:num]
if not p:
break
piece_groups.append(p)
pieces = pieces[num * segments:]
return piece_groups |
recursive glob, gets all files that match the pattern within the directory tree
def rglob(dirname, pattern, dirs=False, sort=True):
"""recursive glob, gets all files that match the pattern within the directory tree"""
fns = []
path = str(dirname)
if os.path.isdir(path):
fns = glob(os.path.join(escape(path), pattern))
dns = [fn for fn
in [os.path.join(path, fn)
for fn in os.listdir(path)]
if os.path.isdir(fn)]
if dirs==True:
fns += dns
for d in dns:
fns += rglob(d, pattern)
if sort==True:
fns.sort()
else:
log.warn("not a directory: %r" % path)
return fns |
Create a new Future whose completion depends on parent futures
The new future will have a function that it calls once all its parents
have completed, the return value of which will be its final value.
There is a special case, however, in which the dependent future's
callback returns a future or list of futures. In those cases, waiting
on the dependent will also wait for all those futures, and the result
(or list of results) of those future(s) will then be the final value.
:param parents:
A list of futures, all of which must be complete before the
dependent's function runs.
:type parents: list
:param function func:
The function to determine the value of the dependent future. It
will take as many arguments as it has parents, and they will be the
results of those futures.
:returns:
a :class:`Dependent`, which is a subclass of :class:`Future` and
has all its capabilities.
def after(parents, func=None):
'''Create a new Future whose completion depends on parent futures
The new future will have a function that it calls once all its parents
have completed, the return value of which will be its final value.
There is a special case, however, in which the dependent future's
callback returns a future or list of futures. In those cases, waiting
on the dependent will also wait for all those futures, and the result
(or list of results) of those future(s) will then be the final value.
:param parents:
A list of futures, all of which must be complete before the
dependent's function runs.
:type parents: list
:param function func:
The function to determine the value of the dependent future. It
will take as many arguments as it has parents, and they will be the
results of those futures.
:returns:
a :class:`Dependent`, which is a subclass of :class:`Future` and
has all its capabilities.
'''
if func is None:
return lambda f: after(parents, f)
dep = Dependent(parents, func)
for parent in parents:
if parent.complete:
dep._incoming(parent, parent.value)
else:
parent._children.append(weakref.ref(dep))
return dep |
Wait for the completion of any (the first) one of multiple futures
:param list futures: A list of :class:`Future`\s
:param timeout:
The maximum time to wait. With ``None``, will block indefinitely.
:type timeout: float or None
:returns:
One of the futures from the provided list -- the first one to become
complete (or any of the ones that were already complete).
:raises WaitTimeout: if a timeout is provided and hit
def wait_any(futures, timeout=None):
'''Wait for the completion of any (the first) one of multiple futures
:param list futures: A list of :class:`Future`\s
:param timeout:
The maximum time to wait. With ``None``, will block indefinitely.
:type timeout: float or None
:returns:
One of the futures from the provided list -- the first one to become
complete (or any of the ones that were already complete).
:raises WaitTimeout: if a timeout is provided and hit
'''
for fut in futures:
if fut.complete:
return fut
wait = _Wait(futures)
for fut in futures:
fut._waits.add(wait)
if wait.done.wait(timeout):
raise errors.WaitTimeout()
return wait.completed_future |
Wait for the completion of all futures in a list
:param list future: a list of :class:`Future`\s
:param timeout:
The maximum time to wait. With ``None``, can block indefinitely.
:type timeout: float or None
:raises WaitTimeout: if a timeout is provided and hit
def wait_all(futures, timeout=None):
'''Wait for the completion of all futures in a list
:param list future: a list of :class:`Future`\s
:param timeout:
The maximum time to wait. With ``None``, can block indefinitely.
:type timeout: float or None
:raises WaitTimeout: if a timeout is provided and hit
'''
if timeout is not None:
deadline = time.time() + timeout
for fut in futures:
fut.wait(deadline - time.time())
else:
for fut in futures:
fut.wait() |
The final value, if it has arrived
:raises: AttributeError, if not yet complete
:raises: an exception if the Future was :meth:`abort`\ed
def value(self):
'''The final value, if it has arrived
:raises: AttributeError, if not yet complete
:raises: an exception if the Future was :meth:`abort`\ed
'''
if not self._done.is_set():
raise AttributeError("value")
if self._failure:
raise self._failure[0], self._failure[1], self._failure[2]
return self._value |
Give the future it's value and trigger any associated callbacks
:param value: the new value for the future
:raises:
:class:`AlreadyComplete <junction.errors.AlreadyComplete>` if
already complete
def finish(self, value):
'''Give the future it's value and trigger any associated callbacks
:param value: the new value for the future
:raises:
:class:`AlreadyComplete <junction.errors.AlreadyComplete>` if
already complete
'''
if self._done.is_set():
raise errors.AlreadyComplete()
self._value = value
for cb in self._cbacks:
backend.schedule(cb, args=(value,))
self._cbacks = None
for wait in list(self._waits):
wait.finish(self)
self._waits = None
for child in self._children:
child = child()
if child is None:
continue
child._incoming(self, value)
self._children = None
self._done.set() |
Finish this future (maybe early) in an error state
Takes a standard exception triple as arguments (like returned by
``sys.exc_info``) and will re-raise them as the value.
Any :class:`Dependents` that are children of this one will also be
aborted.
:param class klass: the class of the exception
:param Exception exc: the exception instance itself
:param traceback tb: the traceback associated with the exception
:raises:
:class:`AlreadyComplete <junction.errors.AlreadyComplete>` if
already complete
def abort(self, klass, exc, tb=None):
'''Finish this future (maybe early) in an error state
Takes a standard exception triple as arguments (like returned by
``sys.exc_info``) and will re-raise them as the value.
Any :class:`Dependents` that are children of this one will also be
aborted.
:param class klass: the class of the exception
:param Exception exc: the exception instance itself
:param traceback tb: the traceback associated with the exception
:raises:
:class:`AlreadyComplete <junction.errors.AlreadyComplete>` if
already complete
'''
if self._done.is_set():
raise errors.AlreadyComplete()
self._failure = (klass, exc, tb)
for eb in self._errbacks:
backend.schedule(eb, args=(klass, exc, tb))
self._errbacks = None
for wait in list(self._waits):
wait.finish(self)
self._waits = None
for child in self._children:
child = child()
if child is None:
continue
child.abort(klass, exc, tb)
self._children = None
self._done.set() |
Assign a callback function to be run when successfully complete
:param function func:
A callback to run when complete. It will be given one argument (the
value that has arrived), and it's return value is ignored.
def on_finish(self, func):
'''Assign a callback function to be run when successfully complete
:param function func:
A callback to run when complete. It will be given one argument (the
value that has arrived), and it's return value is ignored.
'''
if self._done.is_set():
if self._failure is None:
backend.schedule(func, args=(self._value,))
else:
self._cbacks.append(func) |
Assign a callback function to be run when :meth:`abort`\ed
:param function func:
A callback to run when aborted. It will be given three arguments:
- ``klass``: the exception class
- ``exc``: the exception instance
- ``tb``: the traceback object associated with the exception
def on_abort(self, func):
'''Assign a callback function to be run when :meth:`abort`\ed
:param function func:
A callback to run when aborted. It will be given three arguments:
- ``klass``: the exception class
- ``exc``: the exception instance
- ``tb``: the traceback object associated with the exception
'''
if self._done.is_set():
if self._failure is not None:
backend.schedule(func, args=self._failure)
else:
self._errbacks.append(func) |
Create a new Future whose completion depends on this one
The new future will have a function that it calls once all its parents
have completed, the return value of which will be its final value.
There is a special case, however, in which the dependent future's
callback returns a future or list of futures. In those cases, waiting
on the dependent will also wait for all those futures, and the result
(or list of results) of those future(s) will then be the final value.
:param function func:
The function to determine the value of the dependent future. It
will take as many arguments as it has parents, and they will be the
results of those futures.
:param other_parents:
A list of futures, all of which (along with this one) must be
complete before the dependent's function runs.
:type other_parents: list or None
:returns:
a :class:`Dependent`, which is a subclass of :class:`Future` and
has all its capabilities.
def after(self, func=None, other_parents=None):
'''Create a new Future whose completion depends on this one
The new future will have a function that it calls once all its parents
have completed, the return value of which will be its final value.
There is a special case, however, in which the dependent future's
callback returns a future or list of futures. In those cases, waiting
on the dependent will also wait for all those futures, and the result
(or list of results) of those future(s) will then be the final value.
:param function func:
The function to determine the value of the dependent future. It
will take as many arguments as it has parents, and they will be the
results of those futures.
:param other_parents:
A list of futures, all of which (along with this one) must be
complete before the dependent's function runs.
:type other_parents: list or None
:returns:
a :class:`Dependent`, which is a subclass of :class:`Future` and
has all its capabilities.
'''
parents = [self]
if other_parents is not None:
parents += other_parents
return after(parents, func) |
The results that the RPC has received *so far*
This may also be the complete results if :attr:`complete` is ``True``.
def partial_results(self):
'''The results that the RPC has received *so far*
This may also be the complete results if :attr:`complete` is ``True``.
'''
results = []
for r in self._results:
if isinstance(r, Exception):
results.append(type(r)(*deepcopy(r.args)))
elif hasattr(r, "__iter__") and not hasattr(r, "__len__"):
# pass generators straight through
results.append(r)
else:
results.append(deepcopy(r))
return results |
transforms any os path into unix style
def os_path_transform(self, s, sep=os.path.sep):
""" transforms any os path into unix style """
if sep == '/':
return s
else:
return s.replace(sep, '/') |
replaces $tokens$ with values
will be replaced with config rendering
def transform(self, tr_list, files):
"""
replaces $tokens$ with values
will be replaced with config rendering
"""
singular = False
if not isinstance(files, list) and not isinstance(files, tuple):
singular = True
files = [files]
for _find, _replace in tr_list:
files = [opt.replace(_find, _replace) for opt in files]
if singular:
return files[0]
else:
return files |
finds the destination based on source
if source is an absolute path, and there's no pattern, it copies the file to base dst_dir
def resolve_dst(self, dst_dir, src):
"""
finds the destination based on source
if source is an absolute path, and there's no pattern, it copies the file to base dst_dir
"""
if os.path.isabs(src):
return os.path.join(dst_dir, os.path.basename(src))
return os.path.join(dst_dir, src) |
copy the zip file from its filename to the given filename.
def write(self, fn=None):
"""copy the zip file from its filename to the given filename."""
fn = fn or self.fn
if not os.path.exists(os.path.dirname(fn)):
os.makedirs(os.path.dirname(fn))
f = open(self.fn, 'rb')
b = f.read()
f.close()
f = open(fn, 'wb')
f.write(b)
f.close() |
Merge new attributes
def assign(self, attrs):
"""Merge new attributes
"""
for k, v in attrs.items():
setattr(self, k, v) |
Normalizes a single rust frame with a function
def normalize_rust_function(self, function, line):
"""Normalizes a single rust frame with a function"""
# Drop the prefix and return type if there is any
function = drop_prefix_and_return_type(function)
# Collapse types
function = collapse(
function,
open_string='<',
close_string='>',
replacement='<T>',
exceptions=(' as ',)
)
# Collapse arguments
if self.collapse_arguments:
function = collapse(
function,
open_string='(',
close_string=')',
replacement=''
)
if self.signatures_with_line_numbers_re.match(function):
function = '{}:{}'.format(function, line)
# Remove spaces before all stars, ampersands, and commas
function = self.fixup_space.sub('', function)
# Ensure a space after commas
function = self.fixup_comma.sub(', ', function)
# Remove rust-generated uniqueness hashes
function = self.fixup_hash.sub('', function)
return function |
Normalizes a single cpp frame with a function
def normalize_cpp_function(self, function, line):
"""Normalizes a single cpp frame with a function"""
# Drop member function cv/ref qualifiers like const, const&, &, and &&
for ref in ('const', 'const&', '&&', '&'):
if function.endswith(ref):
function = function[:-len(ref)].strip()
# Drop the prefix and return type if there is any if it's not operator
# overloading--operator overloading syntax doesn't have the things
# we're dropping here and can look curious, so don't try
if '::operator' not in function:
function = drop_prefix_and_return_type(function)
# Collapse types
function = collapse(
function,
open_string='<',
close_string='>',
replacement='<T>',
exceptions=('name omitted', 'IPC::ParamTraits')
)
# Collapse arguments
if self.collapse_arguments:
function = collapse(
function,
open_string='(',
close_string=')',
replacement='',
exceptions=('anonymous namespace', 'operator')
)
# Remove PGO cold block labels like "[clone .cold.222]". bug #1397926
if 'clone .cold' in function:
function = collapse(
function,
open_string='[',
close_string=']',
replacement=''
)
if self.signatures_with_line_numbers_re.match(function):
function = '{}:{}'.format(function, line)
# Remove spaces before all stars, ampersands, and commas
function = self.fixup_space.sub('', function)
# Ensure a space after commas
function = self.fixup_comma.sub(', ', function)
return function |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.