sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def __download_from_s3(self, key, dest_dir):
"""Private method for downloading from S3
This private helper method takes a key and the full path to
the destination directory, assumes that the args have been
validated by the public caller methods, and attempts to
download the spec... | Private method for downloading from S3
This private helper method takes a key and the full path to
the destination directory, assumes that the args have been
validated by the public caller methods, and attempts to
download the specified key to the dest_dir.
:param key: (str) S3... | entailment |
def download_file_by_key(self, key, dest_dir):
"""Downloads a file by key from the specified S3 bucket
This method takes the full 'key' as the arg, and attempts to
download the file to the specified dest_dir as the destination
directory. This method sets the downloaded filename to be th... | Downloads a file by key from the specified S3 bucket
This method takes the full 'key' as the arg, and attempts to
download the file to the specified dest_dir as the destination
directory. This method sets the downloaded filename to be the
same as it is on S3.
:param key: (str) ... | entailment |
def download_file(self, regex, dest_dir):
"""Downloads a file by regex from the specified S3 bucket
This method takes a regular expression as the arg, and attempts
to download the file to the specified dest_dir as the
destination directory. This method sets the downloaded filename
... | Downloads a file by regex from the specified S3 bucket
This method takes a regular expression as the arg, and attempts
to download the file to the specified dest_dir as the
destination directory. This method sets the downloaded filename
to be the same as it is on S3.
:param reg... | entailment |
def find_key(self, regex):
"""Attempts to find a single S3 key based on the passed regex
Given a regular expression, this method searches the S3 bucket
for a matching key, and returns it if exactly 1 key matches.
Otherwise, None is returned.
:param regex: (str) Regular expressi... | Attempts to find a single S3 key based on the passed regex
Given a regular expression, this method searches the S3 bucket
for a matching key, and returns it if exactly 1 key matches.
Otherwise, None is returned.
:param regex: (str) Regular expression for an S3 key
:return: (str... | entailment |
def find_keys(self, regex, bucket_name=None):
"""Finds a list of S3 keys matching the passed regex
Given a regular expression, this method searches the S3 bucket
for matching keys, and returns an array of strings for matched
keys, an empty array if non are found.
:param regex: ... | Finds a list of S3 keys matching the passed regex
Given a regular expression, this method searches the S3 bucket
for matching keys, and returns an array of strings for matched
keys, an empty array if non are found.
:param regex: (str) Regular expression to use is the key search
... | entailment |
def upload_file(self, filepath, key):
"""Uploads a file using the passed S3 key
This method uploads a file specified by the filepath to S3
using the provided S3 key.
:param filepath: (str) Full path to the file to be uploaded
:param key: (str) S3 key to be set for the upload
... | Uploads a file using the passed S3 key
This method uploads a file specified by the filepath to S3
using the provided S3 key.
:param filepath: (str) Full path to the file to be uploaded
:param key: (str) S3 key to be set for the upload
:return: True if upload is successful, Fals... | entailment |
def delete_key(self, key_to_delete):
"""Deletes the specified key
:param key_to_delete:
:return:
"""
log = logging.getLogger(self.cls_logger + '.delete_key')
log.info('Attempting to delete key: {k}'.format(k=key_to_delete))
try:
self.s3client.delete_... | Deletes the specified key
:param key_to_delete:
:return: | entailment |
def assert_branch_type(branch_type):
# type: (str) -> None
""" Print error and exit if the current branch is not of a given type.
Args:
branch_type (str):
The branch type. This assumes the branch is in the '<type>/<title>`
format.
"""
branch = git.current_branch(refr... | Print error and exit if the current branch is not of a given type.
Args:
branch_type (str):
The branch type. This assumes the branch is in the '<type>/<title>`
format. | entailment |
def assert_on_branch(branch_name):
# type: (str) -> None
""" Print error and exit if *branch_name* is not the current branch.
Args:
branch_name (str):
The supposed name of the current branch.
"""
branch = git.current_branch(refresh=True)
if branch.name != branch_name:
... | Print error and exit if *branch_name* is not the current branch.
Args:
branch_name (str):
The supposed name of the current branch. | entailment |
def git_branch_delete(branch_name):
# type: (str) -> None
""" Delete the given branch.
Args:
branch_name (str):
Name of the branch to delete.
"""
if branch_name not in git.protected_branches():
log.info("Deleting branch <33>{}", branch_name)
shell.run('git branch... | Delete the given branch.
Args:
branch_name (str):
Name of the branch to delete. | entailment |
def git_branch_rename(new_name):
# type: (str) -> None
""" Rename the current branch
Args:
new_name (str):
New name for the current branch.
"""
curr_name = git.current_branch(refresh=True).name
if curr_name not in git.protected_branches():
log.info("Renaming branch ... | Rename the current branch
Args:
new_name (str):
New name for the current branch. | entailment |
def git_checkout(branch_name, create=False):
# type: (str, bool) -> None
""" Checkout or create a given branch
Args:
branch_name (str):
The name of the branch to checkout or create.
create (bool):
If set to **True** it will create the branch instead of checking it
... | Checkout or create a given branch
Args:
branch_name (str):
The name of the branch to checkout or create.
create (bool):
If set to **True** it will create the branch instead of checking it
out. | entailment |
def git_merge(base, head, no_ff=False):
# type: (str, str, bool) -> None
""" Merge *head* into *base*.
Args:
base (str):
The base branch. *head* will be merged into this branch.
head (str):
The branch that will be merged into *base*.
no_ff (bool):
... | Merge *head* into *base*.
Args:
base (str):
The base branch. *head* will be merged into this branch.
head (str):
The branch that will be merged into *base*.
no_ff (bool):
If set to **True** it will force git to create merge commit. If set
to *... | entailment |
def get_base_branch():
# type: () -> str
""" Return the base branch for the current branch.
This function will first try to guess the base branch and if it can't it
will let the user choose the branch from the list of all local branches.
Returns:
str: The name of the branch the current bra... | Return the base branch for the current branch.
This function will first try to guess the base branch and if it can't it
will let the user choose the branch from the list of all local branches.
Returns:
str: The name of the branch the current branch is based on. | entailment |
def choose_branch(exclude=None):
# type: (List[str]) -> str
""" Show the user a menu to pick a branch from the existing ones.
Args:
exclude (list[str]):
List of branch names to exclude from the menu. By default it will
exclude master and develop branches. To show all branche... | Show the user a menu to pick a branch from the existing ones.
Args:
exclude (list[str]):
List of branch names to exclude from the menu. By default it will
exclude master and develop branches. To show all branches pass an
empty array here.
Returns:
str: The n... | entailment |
def autorun():
'''
Call the run method of the decorated class if the current file is the main file
'''
def wrapper(cls):
import inspect
if inspect.getmodule(cls).__name__ == "__main__":
cls().run()
return cls
return wrapper | Call the run method of the decorated class if the current file is the main file | entailment |
def unique_list(seq):
""" Removes duplicate elements from given @seq
@seq: a #list or sequence-like object
-> #list
"""
seen = set()
seen_add = seen.add
return [x for x in seq if not (x in seen or seen_add(x))] | Removes duplicate elements from given @seq
@seq: a #list or sequence-like object
-> #list | entailment |
def flatten(*seqs):
""" Flattens a sequence e.g. |[(1, 2), (3, (4, 5))] -> [1, 2, 3, 4, 5]|
@seq: #tuple, #list or :class:UserList
-> yields an iterator
..
l = [(1, 2), (3, 4)]
for x in flatten(l):
print(x)
..
"""
for seq in seqs:
... | Flattens a sequence e.g. |[(1, 2), (3, (4, 5))] -> [1, 2, 3, 4, 5]|
@seq: #tuple, #list or :class:UserList
-> yields an iterator
..
l = [(1, 2), (3, 4)]
for x in flatten(l):
print(x)
.. | entailment |
def randrange(seq):
""" Yields random values from @seq until @seq is empty """
seq = seq.copy()
choose = rng().choice
remove = seq.remove
for x in range(len(seq)):
y = choose(seq)
remove(y)
yield y | Yields random values from @seq until @seq is empty | entailment |
def linear_least_squares(a, b, residuals=False):
"""
Return the least-squares solution to a linear matrix equation.
Solves the equation `a x = b` by computing a vector `x` that
minimizes the Euclidean 2-norm `|| b - a x ||^2`. The equation may
be under-, well-, or over- determined (i.e., the number... | Return the least-squares solution to a linear matrix equation.
Solves the equation `a x = b` by computing a vector `x` that
minimizes the Euclidean 2-norm `|| b - a x ||^2`. The equation may
be under-, well-, or over- determined (i.e., the number of
linearly independent rows of `a` can be less than, eq... | entailment |
def validate_ip_address(ip_address):
"""Validate the ip_address
:param ip_address: (str) IP address
:return: (bool) True if the ip_address is valid
"""
# Validate the IP address
log = logging.getLogger(mod_logger + '.validate_ip_address')
if not isinstance(ip_address, basestring):
l... | Validate the ip_address
:param ip_address: (str) IP address
:return: (bool) True if the ip_address is valid | entailment |
def ip_addr():
"""Uses the ip addr command to enumerate IP addresses by device
:return: (dict) Containing device: ip_address
"""
log = logging.getLogger(mod_logger + '.ip_addr')
log.debug('Running the ip addr command...')
ip_addr_output = {}
command = ['ip', 'addr']
try:
ip_add... | Uses the ip addr command to enumerate IP addresses by device
:return: (dict) Containing device: ip_address | entailment |
def alias_ip_address(ip_address, interface, aws=False):
"""Adds an IP alias to a specific interface
Adds an ip address as an alias to the specified interface on
Linux systems.
:param ip_address: (str) IP address to set as an alias
:param interface: (str) The interface number or full device name, i... | Adds an IP alias to a specific interface
Adds an ip address as an alias to the specified interface on
Linux systems.
:param ip_address: (str) IP address to set as an alias
:param interface: (str) The interface number or full device name, if
an int is provided assumes the device name is eth<i>
... | entailment |
def set_source_ip_for_interface(source_ip_address, desired_source_ip_address, device_num=0):
"""Configures the source IP address for a Linux interface
:param source_ip_address: (str) Source IP address to change
:param desired_source_ip_address: (str) IP address to configure as the source in outgoing packet... | Configures the source IP address for a Linux interface
:param source_ip_address: (str) Source IP address to change
:param desired_source_ip_address: (str) IP address to configure as the source in outgoing packets
:param device_num: (int) Integer interface device number to configure
:return: None
:r... | entailment |
def save_logic(self, some_object):
"""
Перед сохранением в методе save вызывается этот метод
:param some_object: сохраненный объект
"""
some_object.validate_model()
some_object.save()
self.send_success_response(data=some_object.to_dict()) | Перед сохранением в методе save вызывается этот метод
:param some_object: сохраненный объект | entailment |
def fmt(msg, *args, **kw):
# type: (str, *Any, **Any) -> str
""" Generate shell color opcodes from a pretty coloring syntax. """
global is_tty
if len(args) or len(kw):
msg = msg.format(*args, **kw)
opcode_subst = '\x1b[\\1m' if is_tty else ''
return re.sub(r'<(\d{1,2})>', opcode_subst,... | Generate shell color opcodes from a pretty coloring syntax. | entailment |
def cprint(msg, *args, **kw):
# type: (str, *Any, **Any) -> None
""" Print colored message to stdout. """
if len(args) or len(kw):
msg = msg.format(*args, **kw)
print(fmt('{}<0>'.format(msg))) | Print colored message to stdout. | entailment |
def run(cmd,
capture=False,
shell=True,
env=None,
exit_on_error=None,
never_pretend=False):
# type: (str, bool, bool, Dict[str, str], bool) -> ExecResult
""" Run a shell command.
Args:
cmd (str):
The shell command to execute.
shell (bool):... | Run a shell command.
Args:
cmd (str):
The shell command to execute.
shell (bool):
Same as in `subprocess.Popen`.
capture (bool):
If set to True, it will capture the standard input/error instead of
just piping it to the caller stdout/stderr.
... | entailment |
def get_payload(request):
"""
Extracts the request's payload information.
This method will merge the URL parameter information
and the JSON body of the request together to generate
a dictionary of key<->value pairings.
This method assumes that the JSON body being provided
is also a key-valu... | Extracts the request's payload information.
This method will merge the URL parameter information
and the JSON body of the request together to generate
a dictionary of key<->value pairings.
This method assumes that the JSON body being provided
is also a key-value map, if it is not, then an HTTPBadRe... | entailment |
def main():
"""Handles external calling for this module
Execute this python module and provide the args shown below to
external call this module to send email messages!
:return: None
"""
log = logging.getLogger(mod_logger + '.main')
parser = argparse.ArgumentParser(description='This module... | Handles external calling for this module
Execute this python module and provide the args shown below to
external call this module to send email messages!
:return: None | entailment |
def send_cons3rt_agent_logs(self):
"""Send the cons3rt agent log file
:return:
"""
log = logging.getLogger(self.cls_logger + '.send_cons3rt_agent_logs')
if self.cons3rt_agent_log_dir is None:
log.warn('There is not CONS3RT agent log directory on this system')
... | Send the cons3rt agent log file
:return: | entailment |
def send_text_file(self, text_file, sender=None, recipient=None):
"""Sends an email with the contents of the provided text file
:return: None
"""
log = logging.getLogger(self.cls_logger + '.send_text_file')
if not isinstance(text_file, basestring):
msg = 'arg text_f... | Sends an email with the contents of the provided text file
:return: None | entailment |
def get_date_range_by_name(name: str, today: datetime=None, tz=None) -> (datetime, datetime):
"""
:param name: yesterday, last_month
:param today: Optional current datetime. Default is now().
:param tz: Optional timezone. Default is UTC.
:return: datetime (begin, end)
"""
if today is None:
... | :param name: yesterday, last_month
:param today: Optional current datetime. Default is now().
:param tz: Optional timezone. Default is UTC.
:return: datetime (begin, end) | entailment |
def parse_date_range_arguments(options: dict, default_range='last_month') -> (datetime, datetime, list):
"""
:param options:
:param default_range: Default datetime range to return if no other selected
:return: begin, end, [(begin1,end1), (begin2,end2), ...]
"""
begin, end = get_date_range_by_nam... | :param options:
:param default_range: Default datetime range to return if no other selected
:return: begin, end, [(begin1,end1), (begin2,end2), ...] | entailment |
def load_elements(self):
#Set atomic data
#atomicData.setDataFile('he_i_rec_Pal12-Pal13.fits')
atomicData.setDataFile('s_iii_coll_HRS12.dat')
#Default: 's_iii_atom_PKW09.dat'
'S3: All energy and A values: Podobedova, Kelleher, and Wiese 2009, J. Phys. Chem. Ref. Data, Vol.'
... | S3: All energy and A values: Podobedova, Kelleher, and Wiese 2009, J. Phys. Chem. Ref. Data, Vol. | entailment |
def git_clone(url, clone_dir, branch='master', username=None, password=None, max_retries=10, retry_sec=30,
git_cmd=None):
"""Clones a git url
:param url: (str) Git URL in https or ssh
:param clone_dir: (str) Path to the desired destination dir
:param branch: (str) branch to clone
:par... | Clones a git url
:param url: (str) Git URL in https or ssh
:param clone_dir: (str) Path to the desired destination dir
:param branch: (str) branch to clone
:param username: (str) username for the git repo
:param password: (str) password for the git repo
:param max_retries: (int) the number of a... | entailment |
def encode_password(password):
"""Performs URL encoding for passwords
:param password: (str) password to encode
:return: (str) encoded password
"""
log = logging.getLogger(mod_logger + '.password_encoder')
log.debug('Encoding password: {p}'.format(p=password))
encoded_password = ''
for ... | Performs URL encoding for passwords
:param password: (str) password to encode
:return: (str) encoded password | entailment |
def encode_character(char):
"""Returns URL encoding for a single character
:param char (str) Single character to encode
:returns (str) URL-encoded character
"""
if char == '!': return '%21'
elif char == '"': return '%22'
elif char == '#': return '%23'
elif char == '$': return '%24'
... | Returns URL encoding for a single character
:param char (str) Single character to encode
:returns (str) URL-encoded character | entailment |
def search_tags_as_filters(tags):
"""Get different tags as dicts ready to use as dropdown lists."""
# set dicts
actions = {}
contacts = {}
formats = {}
inspire = {}
keywords = {}
licenses = {}
md_types = dict()
owners = defaultdict(str)
srs = {}
unused = {}
# 0/1 valu... | Get different tags as dicts ready to use as dropdown lists. | entailment |
def generate(self, verified, keygen):
"""
:param verified: телефон или email (verified_entity)
:param keygen: функция генерации ключа
:return:
"""
return Verification(
verified_entity=verified,
key=keygen(),
verified=False
) | :param verified: телефон или email (verified_entity)
:param keygen: функция генерации ключа
:return: | entailment |
def iban_bank_info(v: str) -> (str, str):
"""
Returns BIC code and bank name from IBAN number.
:param v: IBAN account number
:return: (BIC code, bank name) or ('', '') if not found / unsupported country
"""
v = iban_filter(v)
if v[:2] == 'FI':
return fi_iban_bank_info(v)
else:
... | Returns BIC code and bank name from IBAN number.
:param v: IBAN account number
:return: (BIC code, bank name) or ('', '') if not found / unsupported country | entailment |
def fi_payment_reference_number(num: str):
"""
Appends Finland reference number checksum to existing number.
:param num: At least 3 digits
:return: Number plus checksum
"""
assert isinstance(num, str)
num = STRIP_WHITESPACE.sub('', num)
num = re.sub(r'^0+', '', num)
assert len(num) >... | Appends Finland reference number checksum to existing number.
:param num: At least 3 digits
:return: Number plus checksum | entailment |
def iso_payment_reference_validator(v: str):
"""
Validates ISO reference number checksum.
:param v: Reference number
"""
num = ''
v = STRIP_WHITESPACE.sub('', v)
for ch in v[4:] + v[0:4]:
x = ord(ch)
if ord('0') <= x <= ord('9'):
num += ch
else:
... | Validates ISO reference number checksum.
:param v: Reference number | entailment |
def fi_iban_bank_info(v: str) -> (str, str):
"""
Returns BIC code and bank name from FI IBAN number.
:param v: IBAN account number
:return: (BIC code, bank name) or ('', '') if not found
"""
from jutil.bank_const_fi import FI_BIC_BY_ACCOUNT_NUMBER, FI_BANK_NAME_BY_BIC
v = iban_filter(v)
... | Returns BIC code and bank name from FI IBAN number.
:param v: IBAN account number
:return: (BIC code, bank name) or ('', '') if not found | entailment |
def se_clearing_code_bank_info(clearing: str) -> (str, int):
"""
Returns Sweden bank info by clearning code.
:param clearing: 4-digit clearing code
:return: (Bank name, account digit count) or ('', None) if not found
"""
from jutil.bank_const_se import SE_BANK_CLEARING_LIST
for name, begin, ... | Returns Sweden bank info by clearning code.
:param clearing: 4-digit clearing code
:return: (Bank name, account digit count) or ('', None) if not found | entailment |
def _histplot_bins(column, bins=100):
"""Helper to get bins for histplot."""
col_min = np.min(column)
col_max = np.max(column)
return range(col_min, col_max + 2, max((col_max - col_min) // bins, 1)) | Helper to get bins for histplot. | entailment |
def http_date(value):
""" Formats the @value in required HTTP style
@value: :class:datetime.datetime, #int, #float, #str time-like object
-> #str HTTP-style formatted date
(c)2014, Marcel Hellkamp
"""
if isinstance(value, datetime.datetime):
value = value.utctimetuple()
... | Formats the @value in required HTTP style
@value: :class:datetime.datetime, #int, #float, #str time-like object
-> #str HTTP-style formatted date
(c)2014, Marcel Hellkamp | entailment |
def parse_auth(header):
""" Parse rfc2617 HTTP authentication header string (basic) and return
(user,pass) tuple or None
(c)2014, Marcel Hellkamp
"""
try:
method, data = header.split(None, 1)
if method.lower() == 'basic':
data = base64.b64decode(uniorbytes(data, b... | Parse rfc2617 HTTP authentication header string (basic) and return
(user,pass) tuple or None
(c)2014, Marcel Hellkamp | entailment |
def image(request, data):
"""
Generates identicon image based on passed data.
Arguments:
data - Data which should be used for generating an identicon. This data
will be used in order to create a digest which is used for generating the
identicon. If the data passed is a hex digest already... | Generates identicon image based on passed data.
Arguments:
data - Data which should be used for generating an identicon. This data
will be used in order to create a digest which is used for generating the
identicon. If the data passed is a hex digest already, the digest will be
used as-is.... | entailment |
def rename(name):
# type: (str) -> None
""" Give the currently developed hotfix a new name. """
from peltak.extra.gitflow import logic
if name is None:
name = click.prompt('Hotfix name')
logic.hotfix.rename(name) | Give the currently developed hotfix a new name. | entailment |
def local_lru(obj):
""" Property that maps to a key in a local dict-like attribute.
self._cache must be an OrderedDict
self._cache_size must be defined as LRU size
..
class Foo(object):
def __init__(self, cache_size=5000):
self._cache = OrderedDict()
... | Property that maps to a key in a local dict-like attribute.
self._cache must be an OrderedDict
self._cache_size must be defined as LRU size
..
class Foo(object):
def __init__(self, cache_size=5000):
self._cache = OrderedDict()
self._cache_size... | entailment |
def typed_lru(maxsize, types=None):
""" :func:functools.lru_cache wrapper which allows you to prevent object
types outside of @types from being cached.
The main use case for this is preventing unhashable type errors when
you still want to cache some results.
..
from vita... | :func:functools.lru_cache wrapper which allows you to prevent object
types outside of @types from being cached.
The main use case for this is preventing unhashable type errors when
you still want to cache some results.
..
from vital.cache import typed_lru
@typed... | entailment |
def local_expiring_lru(obj):
""" Property that maps to a key in a local dict-like attribute.
self._cache must be an OrderedDict
self._cache_size must be defined as LRU size
self._cache_ttl is the expiration time in seconds
..
class Foo(object):
def __init__(self,... | Property that maps to a key in a local dict-like attribute.
self._cache must be an OrderedDict
self._cache_size must be defined as LRU size
self._cache_ttl is the expiration time in seconds
..
class Foo(object):
def __init__(self, cache_size=5000, cache_ttl=600):
... | entailment |
def get(self, name, *default):
# type: (str, Any) -> Any
""" Get context value with the given name and optional default.
Args:
name (str):
The name of the context value.
*default (Any):
If given and the key doesn't not exist, this will be ... | Get context value with the given name and optional default.
Args:
name (str):
The name of the context value.
*default (Any):
If given and the key doesn't not exist, this will be returned
instead. If it's not given and the context value doe... | entailment |
def set(self, name, value):
""" Set context value.
Args:
name (str):
The name of the context value to change.
value (Any):
The new value for the selected context value
"""
curr = self.values
parts = name.split('.')
... | Set context value.
Args:
name (str):
The name of the context value to change.
value (Any):
The new value for the selected context value | entailment |
def alias_exists(alias, keystore_path=None, keystore_password='changeit'):
"""Checks if an alias already exists in a keystore
:param alias:
:param keystore_path:
:param keystore_password:
:return: (bool) True when the alias already exists in the keystore
:raises: OSError
"""
log = loggi... | Checks if an alias already exists in a keystore
:param alias:
:param keystore_path:
:param keystore_password:
:return: (bool) True when the alias already exists in the keystore
:raises: OSError | entailment |
def filter(self, query: Query, entity: type) -> Tuple[Query, Any]:
"""Define the filter function that every node must to implement.
:param query: The sqlalchemy query.
:type query: Query
:param entity: The entity model.
:type entity: type
:return: The filtered query.
... | Define the filter function that every node must to implement.
:param query: The sqlalchemy query.
:type query: Query
:param entity: The entity model.
:type entity: type
:return: The filtered query.
:rtype: Tuple[Query, Any] | entailment |
def _extract_relations(self, attribute: str) -> Tuple[List[str], str]:
"""Split and return the list of relation(s) and the attribute.
:param attribute:
:type attribute: str
:return: A tuple where the first element is the list of related
entities and the second is the attrib... | Split and return the list of relation(s) and the attribute.
:param attribute:
:type attribute: str
:return: A tuple where the first element is the list of related
entities and the second is the attribute.
:rtype: Tuple[List[str], str] | entailment |
def _get_relation(self, related_model: type, relations: List[str]) -> Tuple[Optional[List[type]], Optional[type]]:
"""Transform the list of relation to list of class.
:param related_mode: The model of the query.
:type related_mode: type
:param relations: The relation list get from the ... | Transform the list of relation to list of class.
:param related_mode: The model of the query.
:type related_mode: type
:param relations: The relation list get from the `_extract_relations`.
:type relations: List[str]
:return: Tuple with the list of relations (class) and the se... | entailment |
def _join_tables(self, query: Query, join_models: Optional[List[type]]) -> Query:
"""Method to make the join when relation is found.
:param query: The sqlalchemy query.
:type query: Query
:param join_models: The list of joined models get from the method
`_get_relation`.
... | Method to make the join when relation is found.
:param query: The sqlalchemy query.
:type query: Query
:param join_models: The list of joined models get from the method
`_get_relation`.
:type join_models: Optional[List[type]]
:return: The new Query with the joined ... | entailment |
def filter(self, query: Query, entity: type) -> Tuple[Query, Any]:
"""Apply the `_method` to all childs of the node.
:param query: The sqlachemy query.
:type query: Query
:param entity: The entity model of the query.
:type entity: type
:return: A tuple with in ... | Apply the `_method` to all childs of the node.
:param query: The sqlachemy query.
:type query: Query
:param entity: The entity model of the query.
:type entity: type
:return: A tuple with in first place the updated query and in second
place the list of filt... | entailment |
def send_sms(phone: str, message: str, sender: str='', **kw):
"""
Sends SMS via Kajala Group SMS API. Contact info@kajala.com for access.
:param phone: Phone number
:param message: Message to be esnd
:param sender: Sender (max 11 characters)
:param kw: Variable key-value pairs to be sent to SMS ... | Sends SMS via Kajala Group SMS API. Contact info@kajala.com for access.
:param phone: Phone number
:param message: Message to be esnd
:param sender: Sender (max 11 characters)
:param kw: Variable key-value pairs to be sent to SMS API
:return: Response from requests.post | entailment |
def _meta_get_resource_sync(md_uuid):
"""Just a meta func to get execution time"""
isogeo.resource(id_resource=md_uuid)
elapsed = default_timer() - START_TIME
time_completed_at = "{:5.2f}s".format(elapsed)
print("{0:<30} {1:>20}".format(md_uuid, time_completed_at))
return | Just a meta func to get execution time | entailment |
def setup(self, app):
'''
Setup properties from parent app on the command
'''
self.logger = app.logger
self.shell.logger = self.logger
if not self.command_name:
raise EmptyCommandNameException()
self.app = app
self.arguments_declaration = sel... | Setup properties from parent app on the command | entailment |
def process_exception(self, request, e):
"""
Logs exception error message and sends email to ADMINS if hostname is not testserver and DEBUG=False.
:param request: HttpRequest
:param e: Exception
"""
from jutil.email import send_email
assert isinstance(request, Ht... | Logs exception error message and sends email to ADMINS if hostname is not testserver and DEBUG=False.
:param request: HttpRequest
:param e: Exception | entailment |
def get_first_builder_window(builder):
"""Get the first toplevel widget in a Gtk.Builder hierarchy.
This is mostly used for guessing purposes, and an explicit naming is
always going to be a better situation.
"""
for obj in builder.get_objects():
if isinstance(obj, Gtk.Window):
#... | Get the first toplevel widget in a Gtk.Builder hierarchy.
This is mostly used for guessing purposes, and an explicit naming is
always going to be a better situation. | entailment |
def add_slave(self, slave, container_name="widget"):
"""Add a slave delegate
"""
cont = getattr(self, container_name, None)
if cont is None:
raise AttributeError(
'Container name must be a member of the delegate')
cont.add(slave.widget)
self.sl... | Add a slave delegate | entailment |
def get_builder_toplevel(self, builder):
"""Get the toplevel widget from a Gtk.Builder file.
The slave view implementation first searches for the widget named as
self.toplevel_name (which defaults to "main". If this is missing, the
first toplevel widget is discovered in the Builder file... | Get the toplevel widget from a Gtk.Builder file.
The slave view implementation first searches for the widget named as
self.toplevel_name (which defaults to "main". If this is missing, the
first toplevel widget is discovered in the Builder file, and it's
immediate child is used as the to... | entailment |
def show_and_run(self):
"""Show the main widget in a window and run the gtk loop"""
if not self._ui_ready:
self.prepare_ui()
self.display_widget = Gtk.Window()
self.display_widget.add(self.widget)
self.display_widget.show()
self.display_widget.connect('destroy... | Show the main widget in a window and run the gtk loop | entailment |
def get_builder_toplevel(self, builder):
"""Get the toplevel widget from a Gtk.Builder file.
The main view implementation first searches for the widget named as
self.toplevel_name (which defaults to "main". If this is missing, or not
a Gtk.Window, the first toplevel window found in the ... | Get the toplevel widget from a Gtk.Builder file.
The main view implementation first searches for the widget named as
self.toplevel_name (which defaults to "main". If this is missing, or not
a Gtk.Window, the first toplevel window found in the Gtk.Builder is
used. | entailment |
def round_sig(x, sig):
"""Round the number to the specified number of significant figures"""
return round(x, sig - int(floor(log10(abs(x)))) - 1) | Round the number to the specified number of significant figures | entailment |
def open_file(filename, as_text=False):
"""Open the file gunzipping it if it ends with .gz.
If as_text the file is opened in text mode,
otherwise the file's opened in binary mode."""
if filename.lower().endswith('.gz'):
if as_text:
return gzip.open(filename, 'rt')
else:
... | Open the file gunzipping it if it ends with .gz.
If as_text the file is opened in text mode,
otherwise the file's opened in binary mode. | entailment |
def create_simple_writer(outputDef, defaultOutput, outputFormat, fieldNames,
compress=True, valueClassMappings=None,
datasetMetaProps=None, fieldMetaProps=None):
"""Create a simple writer suitable for writing flat data
e.g. as BasicObject or TSV."""
if not ... | Create a simple writer suitable for writing flat data
e.g. as BasicObject or TSV. | entailment |
def write_squonk_datasetmetadata(outputBase, thinOutput, valueClassMappings, datasetMetaProps, fieldMetaProps):
"""This is a temp hack to write the minimal metadata that Squonk needs.
Will needs to be replaced with something that allows something more complete to be written.
:param outputBase: Base name fo... | This is a temp hack to write the minimal metadata that Squonk needs.
Will needs to be replaced with something that allows something more complete to be written.
:param outputBase: Base name for the file to write to
:param thinOutput: Write only new data, not structures. Result type will be BasicObject
... | entailment |
def write_metrics(baseName, values):
"""Write the metrics data
:param baseName: The base name of the output files.
e.g. extensions will be appended to this base name
:param values dictionary of values to write
"""
m = open(baseName + '_metrics.txt', 'w')
for key in values:... | Write the metrics data
:param baseName: The base name of the output files.
e.g. extensions will be appended to this base name
:param values dictionary of values to write | entailment |
def generate_molecule_object_dict(source, format, values):
"""Generate a dictionary that represents a Squonk MoleculeObject when
written as JSON
:param source: Molecules in molfile or smiles format
:param format: The format of the molecule. Either 'mol' or 'smiles'
:param values: Optional dict of v... | Generate a dictionary that represents a Squonk MoleculeObject when
written as JSON
:param source: Molecules in molfile or smiles format
:param format: The format of the molecule. Either 'mol' or 'smiles'
:param values: Optional dict of values (properties) for the MoleculeObject | entailment |
def get_undecorated_calling_module():
"""Returns the module name of the caller's calling module.
If a.py makes a call to b() in b.py, b() can get the name of the
calling module (i.e. a) by calling get_undecorated_calling_module().
The module also includes its full path.
As the name suggests, this ... | Returns the module name of the caller's calling module.
If a.py makes a call to b() in b.py, b() can get the name of the
calling module (i.e. a) by calling get_undecorated_calling_module().
The module also includes its full path.
As the name suggests, this does not work for decorated functions. | entailment |
def query_nexus(query_url, timeout_sec, basic_auth=None):
"""Queries Nexus for an artifact
:param query_url: (str) Query URL
:param timeout_sec: (int) query timeout
:param basic_auth (HTTPBasicAuth) object or none
:return: requests.Response object
:raises: RuntimeError
"""
log = logging... | Queries Nexus for an artifact
:param query_url: (str) Query URL
:param timeout_sec: (int) query timeout
:param basic_auth (HTTPBasicAuth) object or none
:return: requests.Response object
:raises: RuntimeError | entailment |
def get_artifact(suppress_status=False, nexus_url=sample_nexus_url, timeout_sec=600, overwrite=True,
username=None, password=None, **kwargs):
"""Retrieves an artifact from Nexus
:param suppress_status: (bool) Set to True to suppress printing download status
:param nexus_url: (str) URL of t... | Retrieves an artifact from Nexus
:param suppress_status: (bool) Set to True to suppress printing download status
:param nexus_url: (str) URL of the Nexus Server
:param timeout_sec: (int) Number of seconds to wait before
timing out the artifact retrieval.
:param overwrite: (bool) True overwrites... | entailment |
def get_artifact_nexus3(suppress_status=False, nexus_base_url=sample_nexus_base_url, repository=None,
timeout_sec=600, overwrite=True, username=None, password=None, **kwargs):
"""Retrieves an artifact from the Nexus 3 ReST API
:param suppress_status: (bool) Set to True to suppress print... | Retrieves an artifact from the Nexus 3 ReST API
:param suppress_status: (bool) Set to True to suppress printing download status
:param nexus_base_url: (str) Base URL of the Nexus Server (domain name portion only, see sample)
:param repository: (str) Repository to query (e.g. snapshots) if not provided, wil... | entailment |
def main():
"""Handles calling this module as a script
:return: None
"""
log = logging.getLogger(mod_logger + '.main')
parser = argparse.ArgumentParser(description='This Python module retrieves artifacts from Nexus.')
parser.add_argument('-u', '--url', help='Nexus Server URL', required=False)
... | Handles calling this module as a script
:return: None | entailment |
def get_doc(additional_doc=False,
field_prefix='$',
field_suffix=':',
indent=4):
"""Return a formated string containing documentation about the audio
fields.
"""
if additional_doc:
f = fields.copy()
f.update(additional_doc)
else:
f = fields... | Return a formated string containing documentation about the audio
fields. | entailment |
def list_images(self):
# type: () -> List[str]
""" List images stored in the registry.
Returns:
list[str]: List of image names.
"""
r = self.get(self.registry_url + '/v2/_catalog', auth=self.auth)
return r.json()['repositories'] | List images stored in the registry.
Returns:
list[str]: List of image names. | entailment |
def list_tags(self, image_name):
# type: (str) -> Iterator[str]
""" List all tags for the given image stored in the registry.
Args:
image_name (str):
The name of the image to query. The image must be present on the
registry for this call to return any... | List all tags for the given image stored in the registry.
Args:
image_name (str):
The name of the image to query. The image must be present on the
registry for this call to return any values.
Returns:
list[str]: List of tags for that image. | entailment |
def validate_asset_structure(asset_dir_path):
"""Checks asset structure validity
:param asset_dir_path: (str) path to the directory containing the asset
:return: (str) Asset name
:raises: Cons3rtAssetStructureError
"""
log = logging.getLogger(mod_logger + '.validate_asset_structure')
log.i... | Checks asset structure validity
:param asset_dir_path: (str) path to the directory containing the asset
:return: (str) Asset name
:raises: Cons3rtAssetStructureError | entailment |
def make_asset_zip(asset_dir_path, destination_directory=None):
"""Given an asset directory path, creates an asset zip file in the provided
destination directory
:param asset_dir_path: (str) path to the directory containing the asset
:param destination_directory: (str) path to the destination directory... | Given an asset directory path, creates an asset zip file in the provided
destination directory
:param asset_dir_path: (str) path to the directory containing the asset
:param destination_directory: (str) path to the destination directory for
the asset
:return: (str) Path to the asset zip fil... | entailment |
def validate(asset_dir):
"""Command line call to validate an asset structure
:param asset_dir: (full path to the asset dir)
:return: (int)
"""
try:
asset_name = validate_asset_structure(asset_dir_path=asset_dir)
except Cons3rtAssetStructureError:
_, ex, trace = sys.exc_info()
... | Command line call to validate an asset structure
:param asset_dir: (full path to the asset dir)
:return: (int) | entailment |
def create(asset_dir, dest_dir):
"""Command line call to create an asset zip
:param asset_dir: (full path to the asset dir)
:param dest_dir: (full path to the destination directory)
:return: (int)
"""
val = validate(asset_dir=asset_dir)
if val != 0:
return 1
try:
asset_z... | Command line call to create an asset zip
:param asset_dir: (full path to the asset dir)
:param dest_dir: (full path to the destination directory)
:return: (int) | entailment |
def get_object_or_none(cls, **kwargs):
"""
Returns model instance or None if not found.
:param cls: Class or queryset
:param kwargs: Filters for get() call
:return: Object or None
"""
from django.shortcuts import _get_queryset
qs = _get_queryset(cls)
try:
return qs.get(**kwar... | Returns model instance or None if not found.
:param cls: Class or queryset
:param kwargs: Filters for get() call
:return: Object or None | entailment |
def get_model_field_label_and_value(instance, field_name) -> (str, str):
"""
Returns model field label and value.
:param instance: Model instance
:param field_name: Model attribute name
:return: (label, value) tuple
"""
label = field_name
value = str(getattr(instance, field_name))
fo... | Returns model field label and value.
:param instance: Model instance
:param field_name: Model attribute name
:return: (label, value) tuple | entailment |
def clone_model(instance, cls, commit: bool=True, exclude_fields: tuple=('id',), base_class_suffix: str='_ptr', **kw):
"""
Assigns model fields to new object. Ignores exclude_fields list and
attributes ending with pointer suffix (default '_ptr')
:param instance: Instance to copy
:param cls: Class na... | Assigns model fields to new object. Ignores exclude_fields list and
attributes ending with pointer suffix (default '_ptr')
:param instance: Instance to copy
:param cls: Class name
:param commit: Save or not
:param exclude_fields: List of fields to exclude
:param base_class_suffix: End of name fo... | entailment |
def get_queryset(self):
"""
This view should return a list of all the Identities
for the supplied query parameters. The query parameters
should be in the form:
{"address_type": "address"}
e.g.
{"msisdn": "+27123"}
{"email": "foo@bar.com"}
A specia... | This view should return a list of all the Identities
for the supplied query parameters. The query parameters
should be in the form:
{"address_type": "address"}
e.g.
{"msisdn": "+27123"}
{"email": "foo@bar.com"}
A special query paramater "include_inactive" can als... | entailment |
def get_queryset(self):
"""
This view should return a list of all the addresses the identity has
for the supplied query parameters.
Currently only supports address_type and default params
Always excludes addresses with optedout = True
"""
identity_id = self.kwargs... | This view should return a list of all the addresses the identity has
for the supplied query parameters.
Currently only supports address_type and default params
Always excludes addresses with optedout = True | entailment |
def check_internet_connection(self, remote_server: str = "api.isogeo.com") -> bool:
"""Test if an internet connection is operational.
Src: http://stackoverflow.com/a/20913928/2556577.
:param str remote_server: remote server used to check
"""
try:
# see if we can reso... | Test if an internet connection is operational.
Src: http://stackoverflow.com/a/20913928/2556577.
:param str remote_server: remote server used to check | entailment |
def check_bearer_validity(self, token: dict, connect_mtd) -> dict:
"""Check API Bearer token validity.
Isogeo ID delivers authentication bearers which are valid during
a certain time. So this method checks the validity of the token
with a 30 mn anticipation limit, and renews it if neces... | Check API Bearer token validity.
Isogeo ID delivers authentication bearers which are valid during
a certain time. So this method checks the validity of the token
with a 30 mn anticipation limit, and renews it if necessary.
See: http://tools.ietf.org/html/rfc6750#section-2
FI: 2... | entailment |
def check_api_response(self, response):
"""Check API response and raise exceptions if needed.
:param requests.models.Response response: request response to check
"""
# check response
if response.status_code == 200:
return True
elif response.status_code >= 400... | Check API response and raise exceptions if needed.
:param requests.models.Response response: request response to check | entailment |
def check_request_parameters(self, parameters: dict = dict):
"""Check parameters passed to avoid errors and help debug.
:param dict response: search request parameters
"""
# -- SEMANTIC QUERY ---------------------------------------------------
li_args = parameters.get("q").split... | Check parameters passed to avoid errors and help debug.
:param dict response: search request parameters | entailment |
def check_is_uuid(self, uuid_str: str):
"""Check if it's an Isogeo UUID handling specific form.
:param str uuid_str: UUID string to check
"""
# check uuid type
if not isinstance(uuid_str, str):
raise TypeError("'uuid_str' expected a str value.")
else:
... | Check if it's an Isogeo UUID handling specific form.
:param str uuid_str: UUID string to check | entailment |
def check_edit_tab(self, tab: str, md_type: str):
"""Check if asked tab is part of Isogeo web form and reliable
with metadata type.
:param str tab: tab to check. Must be one one of EDIT_TABS attribute
:param str md_type: metadata type. Must be one one of FILTER_TYPES
"""
... | Check if asked tab is part of Isogeo web form and reliable
with metadata type.
:param str tab: tab to check. Must be one one of EDIT_TABS attribute
:param str md_type: metadata type. Must be one one of FILTER_TYPES | entailment |
def _check_filter_specific_md(self, specific_md: list):
"""Check if specific_md parameter is valid.
:param list specific_md: list of specific metadata UUID to check
"""
if isinstance(specific_md, list):
if len(specific_md) > 0:
# checking UUIDs and poping bad... | Check if specific_md parameter is valid.
:param list specific_md: list of specific metadata UUID to check | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.