sentence1 stringlengths 52 3.87M | sentence2 stringlengths 1 47.2k | label stringclasses 1
value |
|---|---|---|
def get_lyrics(artist, song, linesep='\n', timeout=None):
"""Retrieve the lyrics of the song and return the first one in case
multiple versions are available."""
return get_all_lyrics(artist, song, linesep, timeout)[0] | Retrieve the lyrics of the song and return the first one in case
multiple versions are available. | entailment |
def get_all_lyrics(artist, song, linesep='\n', timeout=None):
"""Retrieve a list of all the lyrics versions of a song."""
url = create_url(artist, song)
response = _requests.get(url, timeout=timeout)
soup = _BeautifulSoup(response.content, "html.parser")
lyricboxes = soup.findAll('div', {'class': 'l... | Retrieve a list of all the lyrics versions of a song. | entailment |
def open_file(name, mode=None, driver=None, libver=None, userblock_size=None, **kwargs):
"""Open an ARF file, creating as necessary.
Use this instead of h5py.File to ensure that root-level attributes and group
creation property lists are set correctly.
"""
import sys
import os
from h5py im... | Open an ARF file, creating as necessary.
Use this instead of h5py.File to ensure that root-level attributes and group
creation property lists are set correctly. | entailment |
def create_entry(group, name, timestamp, **attributes):
"""Create a new ARF entry under group, setting required attributes.
An entry is an abstract collection of data which all refer to the same time
frame. Data can include physiological recordings, sound recordings, and
derived data such as spike time... | Create a new ARF entry under group, setting required attributes.
An entry is an abstract collection of data which all refer to the same time
frame. Data can include physiological recordings, sound recordings, and
derived data such as spike times and labels. See add_data() for information
on how data ar... | entailment |
def create_dataset(group, name, data, units='', datatype=DataTypes.UNDEFINED,
chunks=True, maxshape=None, compression=None,
**attributes):
"""Create an ARF dataset under group, setting required attributes
Required arguments:
name -- the name of dataset in which to st... | Create an ARF dataset under group, setting required attributes
Required arguments:
name -- the name of dataset in which to store the data
data -- the data to store
Data can be of the following types:
* sampled data: an N-D numerical array of measurements
* "simple" event data: a 1-D array... | entailment |
def create_table(group, name, dtype, **attributes):
"""Create a new array dataset under group with compound datatype and maxshape=(None,)"""
dset = group.create_dataset(
name, shape=(0,), dtype=dtype, maxshape=(None,))
set_attributes(dset, **attributes)
return dset | Create a new array dataset under group with compound datatype and maxshape=(None,) | entailment |
def append_data(dset, data):
"""Append data to dset along axis 0. Data must be a single element or
a 1D array of the same type as the dataset (including compound datatypes)."""
N = data.shape[0] if hasattr(data, 'shape') else 1
if N == 0:
return
oldlen = dset.shape[0]
newlen = oldlen + N... | Append data to dset along axis 0. Data must be a single element or
a 1D array of the same type as the dataset (including compound datatypes). | entailment |
def check_file_version(file):
"""Check the ARF version attribute of file for compatibility.
Raises DeprecationWarning for backwards-incompatible files, FutureWarning
for (potentially) forwards-incompatible files, and UserWarning for files
that may not have been created by an ARF library.
Returns t... | Check the ARF version attribute of file for compatibility.
Raises DeprecationWarning for backwards-incompatible files, FutureWarning
for (potentially) forwards-incompatible files, and UserWarning for files
that may not have been created by an ARF library.
Returns the version for the file | entailment |
def set_attributes(node, overwrite=True, **attributes):
"""Set multiple attributes on node.
If overwrite is False, and the attribute already exists, does nothing. If
the value for a key is None, the attribute is deleted.
"""
aset = node.attrs
for k, v in attributes.items():
if not over... | Set multiple attributes on node.
If overwrite is False, and the attribute already exists, does nothing. If
the value for a key is None, the attribute is deleted. | entailment |
def keys_by_creation(group):
"""Returns a sequence of links in group in order of creation.
Raises an error if the group was not set to track creation order.
"""
from h5py import h5
out = []
try:
group._id.links.iterate(
out.append, idx_type=h5.INDEX_CRT_ORDER, order=h5.ITER... | Returns a sequence of links in group in order of creation.
Raises an error if the group was not set to track creation order. | entailment |
def convert_timestamp(obj):
"""Make an ARF timestamp from an object.
Argument can be a datetime.datetime object, a time.struct_time, an integer,
a float, or a tuple of integers. The returned value is a numpy array with
the integer number of seconds since the Epoch and any additional
microseconds.
... | Make an ARF timestamp from an object.
Argument can be a datetime.datetime object, a time.struct_time, an integer,
a float, or a tuple of integers. The returned value is a numpy array with
the integer number of seconds since the Epoch and any additional
microseconds.
Note that because floating poin... | entailment |
def timestamp_to_datetime(timestamp):
"""Convert an ARF timestamp to a datetime.datetime object (naive local time)"""
from datetime import datetime, timedelta
obj = datetime.fromtimestamp(timestamp[0])
return obj + timedelta(microseconds=int(timestamp[1])) | Convert an ARF timestamp to a datetime.datetime object (naive local time) | entailment |
def set_uuid(obj, uuid=None):
"""Set the uuid attribute of an HDF5 object. Use this method to ensure correct dtype """
from uuid import uuid4, UUID
if uuid is None:
uuid = uuid4()
elif isinstance(uuid, bytes):
if len(uuid) == 16:
uuid = UUID(bytes=uuid)
else:
... | Set the uuid attribute of an HDF5 object. Use this method to ensure correct dtype | entailment |
def get_uuid(obj):
"""Return the uuid for obj, or null uuid if none is set"""
# TODO: deprecate null uuid ret val
from uuid import UUID
try:
uuid = obj.attrs['uuid']
except KeyError:
return UUID(int=0)
# convert to unicode for python 3
try:
uuid = uuid.decode('ascii')... | Return the uuid for obj, or null uuid if none is set | entailment |
def count_children(obj, type=None):
"""Return the number of children of obj, optionally restricting by class"""
if type is None:
return len(obj)
else:
# there doesn't appear to be any hdf5 function for getting this
# information without inspecting each child, which makes this somewha... | Return the number of children of obj, optionally restricting by class | entailment |
def _todict(cls):
""" generate a dict keyed by value """
return dict((getattr(cls, attr), attr) for attr in dir(cls) if not attr.startswith('_')) | generate a dict keyed by value | entailment |
def get_template(template_name,fields=None):
'''get_template will return a template in the template folder,
with some substitutions (eg, {'{{ graph | safe }}':"fill this in!"}
'''
template = None
if not template_name.endswith('.html'):
template_name = "%s.html" %(template_name)
here = "%... | get_template will return a template in the template folder,
with some substitutions (eg, {'{{ graph | safe }}':"fill this in!"} | entailment |
def container_similarity_vector(container1=None,packages_set=None,by=None):
'''container similarity_vector is similar to compare_packages, but intended
to compare a container object (singularity image or singularity hub container)
to a list of packages. If packages_set is not provided, the default used is
... | container similarity_vector is similar to compare_packages, but intended
to compare a container object (singularity image or singularity hub container)
to a list of packages. If packages_set is not provided, the default used is
'docker-os'. This can be changed to 'docker-library', or if the user wants a cu... | entailment |
def compare_singularity_images(image_paths1, image_paths2=None):
'''compare_singularity_images is a wrapper for compare_containers to compare
singularity containers. If image_paths2 is not defined, pairwise comparison is done
with image_paths1
'''
repeat = False
if image_paths2 is None:
... | compare_singularity_images is a wrapper for compare_containers to compare
singularity containers. If image_paths2 is not defined, pairwise comparison is done
with image_paths1 | entailment |
def compare_containers(container1=None, container2=None):
'''compare_containers will generate a data structure with common and unique files to
two images. If environmental variable SINGULARITY_HUB is set, will use container
database objects.
:param container1: first container for comparison
:param ... | compare_containers will generate a data structure with common and unique files to
two images. If environmental variable SINGULARITY_HUB is set, will use container
database objects.
:param container1: first container for comparison
:param container2: second container for comparison if either not defined ... | entailment |
def compare_lists(list1,list2):
'''compare lists is the lowest level that drives compare_containers and
compare_packages. It returns a comparison object (dict) with the unique,
total, and intersecting things between two lists
:param list1: the list for container1
:param list2: the list for container... | compare lists is the lowest level that drives compare_containers and
compare_packages. It returns a comparison object (dict) with the unique,
total, and intersecting things between two lists
:param list1: the list for container1
:param list2: the list for container2 | entailment |
def calculate_similarity(container1=None,
container2=None,
comparison=None,
metric=None):
'''calculate_similarity will calculate similarity of two containers
by files content, default will calculate
2.0*len(intersect) / to... | calculate_similarity will calculate similarity of two containers
by files content, default will calculate
2.0*len(intersect) / total package1 + total package2
Parameters
==========
container1: container 1
container2: container 2 must be defined or
metric a function to take a total... | entailment |
def package_node(root=None, name=None):
'''package node aims to package a (present working node) for a user into
a container. This assumes that the node is a single partition.
:param root: the root of the node to package, default is /
:param name: the name for the image. If not specified, will use ma... | package node aims to package a (present working node) for a user into
a container. This assumes that the node is a single partition.
:param root: the root of the node to package, default is /
:param name: the name for the image. If not specified, will use machine's
psutil.disk_partitions() | entailment |
def unpack_node(image_path,name=None,output_folder=None,size=None):
'''unpackage node is intended to unpackage a node that was packaged with
package_node. The image should be a .tgz file. The general steps are to:
1. Package the node using the package_node function
2. Transfer the package somewhere that... | unpackage node is intended to unpackage a node that was packaged with
package_node. The image should be a .tgz file. The general steps are to:
1. Package the node using the package_node function
2. Transfer the package somewhere that Singularity is installed | entailment |
def get_build_template(template_name,params=None,to_file=None):
'''get_build template returns a string or file for a particular build template, which is
intended to build a version of a Singularity image on a cloud resource.
:param template_name: the name of the template to retrieve in build/scripts
:pa... | get_build template returns a string or file for a particular build template, which is
intended to build a version of a Singularity image on a cloud resource.
:param template_name: the name of the template to retrieve in build/scripts
:param params: (if needed) a dictionary of parameters to substitute in the... | entailment |
def sniff_extension(file_path,verbose=True):
'''sniff_extension will attempt to determine the file type based on the extension,
and return the proper mimetype
:param file_path: the full path to the file to sniff
:param verbose: print stuff out
'''
mime_types = { "xls": 'application/vnd.ms-exc... | sniff_extension will attempt to determine the file type based on the extension,
and return the proper mimetype
:param file_path: the full path to the file to sniff
:param verbose: print stuff out | entailment |
def get_script(script_name):
'''get_script will return a build script_name, if it is included
in singularity/build/scripts, otherwise will alert the user and return None
:param script_name: the name of the script to look for
'''
install_dir = get_installdir()
script_path = "%s/build/scripts/%s"... | get_script will return a build script_name, if it is included
in singularity/build/scripts, otherwise will alert the user and return None
:param script_name: the name of the script to look for | entailment |
def zip_up(file_list,zip_name,output_folder=None):
'''zip_up will zip up some list of files into a package (.zip)
:param file_list: a list of files to include in the zip.
:param output_folder: the output folder to create the zip in. If not
:param zip_name: the name of the zipfile to return.
specifi... | zip_up will zip up some list of files into a package (.zip)
:param file_list: a list of files to include in the zip.
:param output_folder: the output folder to create the zip in. If not
:param zip_name: the name of the zipfile to return.
specified, a temporary folder will be given. | entailment |
def get_container_contents(container, split_delim=None):
'''get_container_contents will return a list of folders and or files
for a container. The environmental variable SINGULARITY_HUB being set
means that container objects are referenced instead of packages
:param container: the container to get conte... | get_container_contents will return a list of folders and or files
for a container. The environmental variable SINGULARITY_HUB being set
means that container objects are referenced instead of packages
:param container: the container to get content for
:param gets: a list of file names to return, without ... | entailment |
def get_image_hashes(image_path, version=None, levels=None):
'''get_image_hashes returns the hash for an image across all levels. This is the quickest,
easiest way to define a container's reproducibility on each level.
'''
if levels is None:
levels = get_levels(version=version)
hashes = dict... | get_image_hashes returns the hash for an image across all levels. This is the quickest,
easiest way to define a container's reproducibility on each level. | entailment |
def get_image_hash(image_path,
level=None,level_filter=None,
include_files=None,
skip_files=None,
version=None):
'''get_image_hash will generate a sha1 hash of an image, depending on a level
of reproducibility specified by the user. (s... | get_image_hash will generate a sha1 hash of an image, depending on a level
of reproducibility specified by the user. (see function get_levels for descriptions)
the user can also provide a level_filter manually with level_filter (for custom levels)
:param level: the level of reproducibility to use, which map... | entailment |
def get_content_hashes(image_path,
level=None,
regexp=None,
include_files=None,
tag_root=True,
level_filter=None,
skip_files=None,
version=None,
... | get_content_hashes is like get_image_hash, but it returns a complete dictionary
of file names (keys) and their respective hashes (values). This function is intended
for more research purposes and was used to generate the levels in the first place.
If include_sizes is True, we include a second data structur... | entailment |
def get_image_file_hash(image_path):
'''get_image_hash will return an md5 hash of the file based on a criteria level.
:param level: one of LOW, MEDIUM, HIGH
:param image_path: full path to the singularity image
'''
hasher = hashlib.md5()
with open(image_path, "rb") as f:
for chunk in ite... | get_image_hash will return an md5 hash of the file based on a criteria level.
:param level: one of LOW, MEDIUM, HIGH
:param image_path: full path to the singularity image | entailment |
def container_difference(container=None,container_subtract=None,image_package=None,
image_package_subtract=None,comparison=None):
'''container_difference will return a data structure to render an html
tree (graph) of the differences between two images or packages. The second
contai... | container_difference will return a data structure to render an html
tree (graph) of the differences between two images or packages. The second
container is subtracted from the first
:param container: the primary container object (to subtract from)
:param container_subtract: the second container object ... | entailment |
def container_similarity(container1=None,container2=None,image_package1=None,
image_package2=None,comparison=None):
'''container_sim will return a data structure to render an html tree
(graph) of the intersection (commonalities) between two images or packages
:param container1: the... | container_sim will return a data structure to render an html tree
(graph) of the intersection (commonalities) between two images or packages
:param container1: the first container object
:param container2: the second container object if either not defined, need
:param image_package1: a packaged contain... | entailment |
def container_tree(container=None,image_package=None):
'''tree will render an html tree (graph) of a container
'''
guts = get_container_contents(container=container,
image_package=image_package,
split_delim="\n")
# Make the tree and r... | tree will render an html tree (graph) of a container | entailment |
def make_container_tree(folders,files,path_delim="/",parse_files=True):
'''make_container_tree will convert a list of folders and files into a json structure that represents a graph.
:param folders: a list of folders in the image
:param files: a list of files in the folder
:param parse_files: return 'fi... | make_container_tree will convert a list of folders and files into a json structure that represents a graph.
:param folders: a list of folders in the image
:param files: a list of files in the folder
:param parse_files: return 'files' lookup in result, to associate ID of node with files (default True)
:p... | entailment |
def make_package_tree(matrix=None,labels=None,width=25,height=10,title=None,font_size=None):
'''make package tree will make a dendrogram comparing a matrix of packages
:param matrix: a pandas df of packages, with names in index and columns
:param labels: a list of labels corresponding to row names, will be
... | make package tree will make a dendrogram comparing a matrix of packages
:param matrix: a pandas df of packages, with names in index and columns
:param labels: a list of labels corresponding to row names, will be
pulled from rows if not defined
:param title: a title for the plot, if not defined, will be ... | entailment |
def make_interactive_tree(matrix=None,labels=None):
'''make interactive tree will return complete html for an interactive tree
:param title: a title for the plot, if not defined, will be left out.
'''
from scipy.cluster.hierarchy import (
dendrogram,
linkage,
to_tree
)
... | make interactive tree will return complete html for an interactive tree
:param title: a title for the plot, if not defined, will be left out. | entailment |
def add_node(node, parent):
'''add_node will add a node to it's parent
'''
newNode = dict(node_id=node.id, children=[])
parent["children"].append(newNode)
if node.left: add_node(node.left, newNode)
if node.right: add_node(node.right, newNode) | add_node will add a node to it's parent | entailment |
def label_tree(n,lookup):
'''label tree will again recursively label the tree
:param n: the root node, usually d3['children'][0]
:param lookup: the node/id lookup
'''
if len(n["children"]) == 0:
leaves = [lookup[n["node_id"]]]
else:
leaves = reduce(lambda ls, c: ls + label_tree(c... | label tree will again recursively label the tree
:param n: the root node, usually d3['children'][0]
:param lookup: the node/id lookup | entailment |
def extract_apps(image, app_names):
''' extract app will extract metadata for one or more apps
Parameters
==========
image: the absolute path to the image
app_name: the name of the app under /scif/apps
'''
apps = dict()
if isinstance(app_names, tuple):
app_names... | extract app will extract metadata for one or more apps
Parameters
==========
image: the absolute path to the image
app_name: the name of the app under /scif/apps | entailment |
def run_command(cmd, sudo=False):
'''run_command uses subprocess to send a command to the terminal.
:param cmd: the command to send, should be a list for subprocess
:param error_message: the error message to give to user if fails,
if none specified, will alert that command failed.
:param sudopw: if ... | run_command uses subprocess to send a command to the terminal.
:param cmd: the command to send, should be a list for subprocess
:param error_message: the error message to give to user if fails,
if none specified, will alert that command failed.
:param sudopw: if specified (not None) command will be run ... | entailment |
def download_repo(repo_url, destination, commit=None):
'''download_repo
:param repo_url: the url of the repo to clone from
:param destination: the full path to the destination for the repo
'''
command = "git clone %s %s" % (repo_url, destination)
os.system(command)
return destination | download_repo
:param repo_url: the url of the repo to clone from
:param destination: the full path to the destination for the repo | entailment |
def get_tags(container=None,
search_folders=None,
file_list=None,
return_unique=True):
'''get tags will return a list of tags that describe the software in an image,
meaning inside of a paricular folder. If search_folder is not defined, uses lib
:param container: if p... | get tags will return a list of tags that describe the software in an image,
meaning inside of a paricular folder. If search_folder is not defined, uses lib
:param container: if provided, will use container as image. Can also provide
:param image_package: if provided, can be used instead of container
:pa... | entailment |
def file_counts(container=None,
patterns=None,
image_package=None,
file_list=None):
'''file counts will return a list of files that match one or more regular expressions.
if no patterns is defined, a default of readme is used. All patterns and files are made
... | file counts will return a list of files that match one or more regular expressions.
if no patterns is defined, a default of readme is used. All patterns and files are made
case insensitive.
Parameters
==========
:param container: if provided, will use container as image. Can also provide
:param... | entailment |
def extension_counts(container=None, file_list=None, return_counts=True):
'''extension counts will return a dictionary with counts of file extensions for
an image.
:param container: if provided, will use container as image. Can also provide
:param image_package: if provided, can be used instead of conta... | extension counts will return a dictionary with counts of file extensions for
an image.
:param container: if provided, will use container as image. Can also provide
:param image_package: if provided, can be used instead of container
:param file_list: the complete list of files
:param return_counts: r... | entailment |
def assess_differences(image_file1,
image_file2,
levels=None,
version=None,
size_heuristic=False,
guts1=None,
guts2=None):
'''assess_differences will compare two images on each ... | assess_differences will compare two images on each level of
reproducibility, returning for each level a dictionary with files
that are the same, different, and an overall score.
:param size_heuristic: if True, assess root owned files based on size
:param guts1,guts2: the result (dict with sizes,roots,e... | entailment |
def include_file(member,file_filter):
'''include_file will look at a path and determine
if it matches a regular expression from a level
'''
member_path = member.name.replace('.','',1)
if len(member_path) == 0:
return False
# Does the filter skip it explicitly?
if "skip_files" in fi... | include_file will look at a path and determine
if it matches a regular expression from a level | entailment |
def is_root_owned(member):
'''assess if a file is root owned, meaning "root" or user/group
id of 0'''
if member.uid == 0 or member.gid == 0:
return True
elif member.uname == 'root' or member.gname == 'root':
return True
return False | assess if a file is root owned, meaning "root" or user/group
id of 0 | entailment |
def assess_content(member,file_filter):
'''Determine if the filter wants the file to be read for content.
In the case of yes, we would then want to add the content to the
hash and not the file object.
'''
member_path = member.name.replace('.','',1)
if len(member_path) == 0:
return False... | Determine if the filter wants the file to be read for content.
In the case of yes, we would then want to add the content to the
hash and not the file object. | entailment |
def get_custom_level(regexp=None,description=None,skip_files=None,include_files=None):
'''get_custom_level will generate a custom level for the user,
based on a regular expression. If used outside the context of tarsum, the user
can generate their own named and described filters.
:param regexp: must be... | get_custom_level will generate a custom level for the user,
based on a regular expression. If used outside the context of tarsum, the user
can generate their own named and described filters.
:param regexp: must be defined, the file filter regular expression
:param description: optional description | entailment |
def get_level(level,version=None,include_files=None,skip_files=None):
'''get_level returns a single level, with option to customize files
added and skipped.
'''
levels = get_levels(version=version)
level_names = list(levels.keys())
if level.upper() in level_names:
level = levels[level]... | get_level returns a single level, with option to customize files
added and skipped. | entailment |
def modify_level(level,field,values,append=True):
'''modify level is intended to add / modify a content type.
Default content type is list, meaning the entry is appended.
If you set append to False, the content will be overwritten
For any other content type, the entry is overwritten.
'''
field =... | modify level is intended to add / modify a content type.
Default content type is list, meaning the entry is appended.
If you set append to False, the content will be overwritten
For any other content type, the entry is overwritten. | entailment |
def get_levels(version=None):
'''get_levels returns a dictionary of levels (key) and values (dictionaries with
descriptions and regular expressions for files) for the user.
:param version: the version of singularity to use (default is 2.2)
:param include_files: files to add to the level, only relvant i... | get_levels returns a dictionary of levels (key) and values (dictionaries with
descriptions and regular expressions for files) for the user.
:param version: the version of singularity to use (default is 2.2)
:param include_files: files to add to the level, only relvant if | entailment |
def make_levels_set(levels):
'''make set efficient will convert all lists of items
in levels to a set to speed up operations'''
for level_key,level_filters in levels.items():
levels[level_key] = make_level_set(level_filters)
return levels | make set efficient will convert all lists of items
in levels to a set to speed up operations | entailment |
def make_level_set(level):
'''make level set will convert one level into
a set'''
new_level = dict()
for key,value in level.items():
if isinstance(value,list):
new_level[key] = set(value)
else:
new_level[key] = value
return new_level | make level set will convert one level into
a set | entailment |
def extract_guts(image_path,
tar,
file_filter=None,
tag_root=True,
include_sizes=True):
'''extract the file guts from an in memory tarfile. The file is not closed.
This should not be done for large images.
'''
if file_filter is None... | extract the file guts from an in memory tarfile. The file is not closed.
This should not be done for large images. | entailment |
def get_memory_tar(image_path):
'''get an in memory tar of an image. Use carefully, not as reliable
as get_image_tar
'''
byte_array = Client.image.export(image_path)
file_object = io.BytesIO(byte_array)
tar = tarfile.open(mode="r|*", fileobj=file_object)
return (file_object,tar) | get an in memory tar of an image. Use carefully, not as reliable
as get_image_tar | entailment |
def get_image_tar(image_path):
'''get an image tar, either written in memory or to
the file system. file_obj will either be the file object,
or the file itself.
'''
bot.debug('Generate file system tar...')
file_obj = Client.image.export(image_path=image_path)
if file_obj is None:
... | get an image tar, either written in memory or to
the file system. file_obj will either be the file object,
or the file itself. | entailment |
def delete_image_tar(file_obj, tar):
'''delete image tar will close a file object (if extracted into
memory) or delete from the file system (if saved to disk)'''
try:
file_obj.close()
except:
tar.close()
if os.path.exists(file_obj):
os.remove(file_obj)
deleted = True
... | delete image tar will close a file object (if extracted into
memory) or delete from the file system (if saved to disk) | entailment |
def extract_content(image_path, member_name, return_hash=False):
'''extract_content will extract content from an image using cat.
If hash=True, a hash sum is returned instead
'''
if member_name.startswith('./'):
member_name = member_name.replace('.','',1)
if return_hash:
hashy = hash... | extract_content will extract content from an image using cat.
If hash=True, a hash sum is returned instead | entailment |
def run_build(build_dir, params, verbose=True):
'''run_build takes a build directory and params dictionary, and does the following:
- downloads repo to a temporary directory
- changes branch or commit, if needed
- creates and bootstraps singularity image from Singularity file
- returns a dic... | run_build takes a build directory and params dictionary, and does the following:
- downloads repo to a temporary directory
- changes branch or commit, if needed
- creates and bootstraps singularity image from Singularity file
- returns a dictionary with:
image (path), metadata (dict)
... | entailment |
def send_build_data(build_dir, data, secret,
response_url=None,clean_up=True):
'''finish build sends the build and data (response) to a response url
:param build_dir: the directory of the build
:response_url: where to send the response. If None, won't send
:param data: the data obje... | finish build sends the build and data (response) to a response url
:param build_dir: the directory of the build
:response_url: where to send the response. If None, won't send
:param data: the data object to send as a post
:param clean_up: If true (default) removes build directory | entailment |
def send_build_close(params,response_url):
'''send build close sends a final response (post) to the server to bring down
the instance. The following must be included in params:
repo_url, logfile, repo_id, secret, log_file, token
'''
# Finally, package everything to send back to shub
response = ... | send build close sends a final response (post) to the server to bring down
the instance. The following must be included in params:
repo_url, logfile, repo_id, secret, log_file, token | entailment |
def remove_unicode_dict(input_dict):
'''remove unicode keys and values from dict, encoding in utf8
'''
if isinstance(input_dict, collections.Mapping):
return dict(map(remove_unicode_dict, input_dict.iteritems()))
elif isinstance(input_dict, collections.Iterable):
return type(input_dict)(... | remove unicode keys and values from dict, encoding in utf8 | entailment |
def update_dict(input_dict,key,value):
'''update_dict will update lists in a dictionary. If the key is not included,
if will add as new list. If it is, it will append.
:param input_dict: the dict to update
:param value: the value to update with
'''
if key in input_dict:
input_dict[key].a... | update_dict will update lists in a dictionary. If the key is not included,
if will add as new list. If it is, it will append.
:param input_dict: the dict to update
:param value: the value to update with | entailment |
def update_dict_sum(input_dict,key,increment=None,initial_value=None):
'''update_dict sum will increment a dictionary key
by an increment, and add a value of 0 if it doesn't exist
:param input_dict: the dict to update
:param increment: the value to increment by. Default is 1
:param initial_value: v... | update_dict sum will increment a dictionary key
by an increment, and add a value of 0 if it doesn't exist
:param input_dict: the dict to update
:param increment: the value to increment by. Default is 1
:param initial_value: value to start with. Default is 0 | entailment |
def information_coefficient(total1,total2,intersect):
'''a simple jacaard (information coefficient) to compare two lists of overlaps/diffs
'''
total = total1 + total2
return 2.0*len(intersect) / total | a simple jacaard (information coefficient) to compare two lists of overlaps/diffs | entailment |
def RSA(m1,m2):
'''RSA analysis will compare the similarity of two matrices
'''
from scipy.stats import pearsonr
import scipy.linalg
import numpy
# This will take the diagonal of each matrix (and the other half is changed to nan) and flatten to vector
vectorm1 = m1.mask(numpy.triu(numpy.one... | RSA analysis will compare the similarity of two matrices | entailment |
def get_google_service(service_type=None,version=None):
'''
get_url will use the requests library to get a url
:param service_type: the service to get (default is storage)
:param version: version to use (default is v1)
'''
if service_type == None:
service_type = "storage"
if version ... | get_url will use the requests library to get a url
:param service_type: the service to get (default is storage)
:param version: version to use (default is v1) | entailment |
def upload_file(storage_service,bucket,bucket_path,file_name,verbose=True):
'''get_folder will return the folder with folder_name, and if create=True,
will create it if not found. If folder is found or created, the metadata is
returned, otherwise None is returned
:param storage_service: the drive_servic... | get_folder will return the folder with folder_name, and if create=True,
will create it if not found. If folder is found or created, the metadata is
returned, otherwise None is returned
:param storage_service: the drive_service created from get_storage_service
:param bucket: the bucket object from get_bu... | entailment |
def get_image_path(repo_url, trailing_path):
'''get_image_path will determine an image path based on a repo url, removing
any token, and taking into account urls that end with .git.
:param repo_url: the repo url to parse:
:param trailing_path: the trailing path (commit then hash is common)
'''
r... | get_image_path will determine an image path based on a repo url, removing
any token, and taking into account urls that end with .git.
:param repo_url: the repo url to parse:
:param trailing_path: the trailing path (commit then hash is common) | entailment |
def run_build(logfile='/tmp/.shub-log'):
'''run_build will generate the Singularity build from a spec_file from a repo_url.
If no arguments are required, the metadata api is queried for the values.
:param build_dir: directory to do the build in. If not specified, will use temporary.
:param spec_fi... | run_build will generate the Singularity build from a spec_file from a repo_url.
If no arguments are required, the metadata api is queried for the values.
:param build_dir: directory to do the build in. If not specified, will use temporary.
:param spec_file: the spec_file name to use, assumed to be in g... | entailment |
def finish_build(verbose=True):
'''finish_build will finish the build by way of sending the log to the same bucket.
the params are loaded from the previous function that built the image, expected in
$HOME/params.pkl
:: note: this function is currently configured to work with Google Compute
Engine me... | finish_build will finish the build by way of sending the log to the same bucket.
the params are loaded from the previous function that built the image, expected in
$HOME/params.pkl
:: note: this function is currently configured to work with Google Compute
Engine metadata api, and should (will) be custom... | entailment |
def get_build_metadata(key):
'''get_build_metadata will return metadata about an instance from within it.
:param key: the key to look up
'''
headers = {"Metadata-Flavor":"Google"}
url = "http://metadata.google.internal/computeMetadata/v1/instance/attributes/%s" %(key)
response = requests... | get_build_metadata will return metadata about an instance from within it.
:param key: the key to look up | entailment |
def get_build_params(metadata):
'''get_build_params uses get_build_metadata to retrieve corresponding meta data values for a build
:param metadata: a list, each item a dictionary of metadata, in format:
metadata = [{'key': 'repo_url', 'value': repo_url },
{'key': 'repo_id', 'value': repo_id ... | get_build_params uses get_build_metadata to retrieve corresponding meta data values for a build
:param metadata: a list, each item a dictionary of metadata, in format:
metadata = [{'key': 'repo_url', 'value': repo_url },
{'key': 'repo_id', 'value': repo_id },
{'key': 'credential'... | entailment |
def rsync(*args, **kwargs):
""" wrapper around the rsync command.
the ssh connection arguments are set automatically.
any args are just passed directly to rsync.
you can use {host_string} in place of the server.
the kwargs are passed on the 'local' fabric command.
if not s... | wrapper around the rsync command.
the ssh connection arguments are set automatically.
any args are just passed directly to rsync.
you can use {host_string} in place of the server.
the kwargs are passed on the 'local' fabric command.
if not set, 'capture' is set to False.
... | entailment |
def bootstrap(**kwargs):
""" Bootstrap an EC2 instance that has been booted into an AMI from http://www.daemonology.net/freebsd-on-ec2/
Note: deprecated, current AMI images are basically pre-bootstrapped, they just need to be configured.
"""
# the user for the image is `ec2-user`, there is no sudo, but ... | Bootstrap an EC2 instance that has been booted into an AMI from http://www.daemonology.net/freebsd-on-ec2/
Note: deprecated, current AMI images are basically pre-bootstrapped, they just need to be configured. | entailment |
def bootstrap(**kwargs):
"""Digital Oceans FreeBSD droplets are pretty much already pre-bootstrapped,
including having python2.7 and sudo etc. pre-installed.
the only thing we need to change is to allow root to login (without a password)
enable pf and ensure it is running
"""
bu = BootstrapUtil... | Digital Oceans FreeBSD droplets are pretty much already pre-bootstrapped,
including having python2.7 and sudo etc. pre-installed.
the only thing we need to change is to allow root to login (without a password)
enable pf and ensure it is running | entailment |
def bootstrap_files(self):
""" we need some files to bootstrap the FreeBSD installation.
Some...
- need to be provided by the user (i.e. authorized_keys)
- others have some (sensible) defaults (i.e. rc.conf)
- some can be downloaded via URL (i.e.) http://pkg.freebsd.o... | we need some files to bootstrap the FreeBSD installation.
Some...
- need to be provided by the user (i.e. authorized_keys)
- others have some (sensible) defaults (i.e. rc.conf)
- some can be downloaded via URL (i.e.) http://pkg.freebsd.org/freebsd:10:x86:64/latest/Latest/pkg.... | entailment |
def devices(self):
""" computes the name of the disk devices that are suitable
installation targets by subtracting CDROM- and USB devices
from the list of total mounts.
"""
install_devices = self.install_devices
if 'bootstrap-system-devices' in env.instance.config:
... | computes the name of the disk devices that are suitable
installation targets by subtracting CDROM- and USB devices
from the list of total mounts. | entailment |
def fetch_assets(self):
""" download bootstrap assets to control host.
If present on the control host they will be uploaded to the target host during bootstrapping.
"""
# allow overwrites from the commandline
packages = set(
env.instance.config.get('bootstrap-packages... | download bootstrap assets to control host.
If present on the control host they will be uploaded to the target host during bootstrapping. | entailment |
def res_to_str(res):
"""
:param res: :class:`requests.Response` object
Parse the given request and generate an informative string from it
"""
if 'Authorization' in res.request.headers:
res.request.headers['Authorization'] = "*****"
return """
####################################
url = %... | :param res: :class:`requests.Response` object
Parse the given request and generate an informative string from it | entailment |
def parse_resource_definition(resource_name, resource_dct):
"""
Returns all the info extracted from a resource section of the apipie json
:param resource_name: Name of the resource that is defined by the section
:param resrouce_dict: Dictionary as generated by apipie of the resource
definition
... | Returns all the info extracted from a resource section of the apipie json
:param resource_name: Name of the resource that is defined by the section
:param resrouce_dict: Dictionary as generated by apipie of the resource
definition | entailment |
def parse_resource_from_url(self, url):
"""
Returns the appropriate resource name for the given URL.
:param url: API URL stub, like: '/api/hosts'
:return: Resource name, like 'hosts', or None if not found
"""
# special case for the api root
if url == '/api':
... | Returns the appropriate resource name for the given URL.
:param url: API URL stub, like: '/api/hosts'
:return: Resource name, like 'hosts', or None if not found | entailment |
def _get_name(self):
"""
There are three cases, because apipie definitions can have multiple
signatures but python does not
For example, the api endpoint:
/api/myres/:myres_id/subres/:subres_id/subres2
for method *index* will be translated to the api method name:
... | There are three cases, because apipie definitions can have multiple
signatures but python does not
For example, the api endpoint:
/api/myres/:myres_id/subres/:subres_id/subres2
for method *index* will be translated to the api method name:
subres_index_subres2
So ... | entailment |
def generate_func(self, as_global=False):
"""
Generate function for specific method and using specific api
:param as_global: if set, will use the global function name, instead of
the class method (usually {resource}_{class_method}) when defining
the function
"""
... | Generate function for specific method and using specific api
:param as_global: if set, will use the global function name, instead of
the class method (usually {resource}_{class_method}) when defining
the function | entailment |
def create_param_doc(cls, param, prefix=None):
"""
Generate documentation for single parameter of function
:param param: dict contains info about parameter
:param sub: prefix string for recursive purposes
"""
desc = cls.exclude_html_reg.sub('', param['description']).strip... | Generate documentation for single parameter of function
:param param: dict contains info about parameter
:param sub: prefix string for recursive purposes | entailment |
def convert_plugin_def(http_method, funcs):
"""
This function parses one of the elements of the definitions dict for a
plugin and extracts the relevant information
:param http_method: HTTP method that uses (GET, POST, DELETE, ...)
:param funcs: functions related to that HTTP met... | This function parses one of the elements of the definitions dict for a
plugin and extracts the relevant information
:param http_method: HTTP method that uses (GET, POST, DELETE, ...)
:param funcs: functions related to that HTTP method | entailment |
def get_current_version(repo_path):
"""
Given a repo will return the version string, according to semantic
versioning, counting as non-backwards compatible commit any one with a
message header that matches (case insensitive)::
sem-ver: .*break.*
And as features any commit with a header mat... | Given a repo will return the version string, according to semantic
versioning, counting as non-backwards compatible commit any one with a
message header that matches (case insensitive)::
sem-ver: .*break.*
And as features any commit with a header matching::
sem-ver: feature
And count... | entailment |
def get_authors(repo_path, from_commit):
"""
Given a repo and optionally a base revision to start from, will return
the list of authors.
"""
repo = dulwich.repo.Repo(repo_path)
refs = get_refs(repo)
start_including = False
authors = set()
if from_commit is None:
start_includ... | Given a repo and optionally a base revision to start from, will return
the list of authors. | entailment |
def emit(
self, tup, tup_id=None, stream=None, direct_task=None, need_task_ids=False
):
"""Emit a spout Tuple message.
:param tup: the Tuple to send to Storm, should contain only
JSON-serializable data.
:type tup: list or tuple
:param tup_id: the ID for t... | Emit a spout Tuple message.
:param tup: the Tuple to send to Storm, should contain only
JSON-serializable data.
:type tup: list or tuple
:param tup_id: the ID for the Tuple. Leave this blank for an
unreliable emit.
:type tup_id: str
:pa... | entailment |
def _run(self):
"""The inside of ``run``'s infinite loop.
Separated out so it can be properly unit tested.
"""
cmd = self.read_command()
if cmd["command"] == "next":
self.next_tuple()
elif cmd["command"] == "ack":
self.ack(cmd["id"])
elif ... | The inside of ``run``'s infinite loop.
Separated out so it can be properly unit tested. | entailment |
def ack(self, tup_id):
"""Called when a bolt acknowledges a Tuple in the topology.
:param tup_id: the ID of the Tuple that has been fully acknowledged in
the topology.
:type tup_id: str
"""
self.failed_tuples.pop(tup_id, None)
try:
del ... | Called when a bolt acknowledges a Tuple in the topology.
:param tup_id: the ID of the Tuple that has been fully acknowledged in
the topology.
:type tup_id: str | entailment |
def fail(self, tup_id):
"""Called when a Tuple fails in the topology
A reliable spout will replay a failed tuple up to ``max_fails`` times.
:param tup_id: the ID of the Tuple that has failed in the topology
either due to a bolt calling ``fail()`` or a Tuple
... | Called when a Tuple fails in the topology
A reliable spout will replay a failed tuple up to ``max_fails`` times.
:param tup_id: the ID of the Tuple that has failed in the topology
either due to a bolt calling ``fail()`` or a Tuple
timing out.
:type... | entailment |
def emit(
self, tup, tup_id=None, stream=None, direct_task=None, need_task_ids=False
):
"""Emit a spout Tuple & add metadata about it to `unacked_tuples`.
In order for this to work, `tup_id` is a required parameter.
See :meth:`Bolt.emit`.
"""
if tup_id is None:
... | Emit a spout Tuple & add metadata about it to `unacked_tuples`.
In order for this to work, `tup_id` is a required parameter.
See :meth:`Bolt.emit`. | entailment |
def remote_pdb_handler(signum, frame):
""" Handler to drop us into a remote debugger upon receiving SIGUSR1 """
try:
from remote_pdb import RemotePdb
rdb = RemotePdb(host="127.0.0.1", port=0)
rdb.set_trace(frame=frame)
except ImportError:
log.warning(
"remote_pdb... | Handler to drop us into a remote debugger upon receiving SIGUSR1 | entailment |
def emit(self, record):
"""
Emit a record.
If a formatter is specified, it is used to format the record.
If exception information is present, it is formatted using
traceback.print_exception and sent to Storm.
"""
try:
msg = self.format(record)
... | Emit a record.
If a formatter is specified, it is used to format the record.
If exception information is present, it is formatted using
traceback.print_exception and sent to Storm. | entailment |
def _setup_component(self, storm_conf, context):
"""Add helpful instance variables to component after initial handshake
with Storm. Also configure logging.
"""
self.topology_name = storm_conf.get("topology.name", "")
self.task_id = context.get("taskid", "")
self.componen... | Add helpful instance variables to component after initial handshake
with Storm. Also configure logging. | entailment |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.