_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q8700 | render_cvmfs_pvc | train | def render_cvmfs_pvc(cvmfs_volume):
"""Render REANA_CVMFS_PVC_TEMPLATE."""
name = CVMFS_REPOSITORIES[cvmfs_volume]
rendered_template = dict(REANA_CVMFS_PVC_TEMPLATE)
rendered_template['metadata']['name'] = 'csi-cvmfs-{}-pvc'.format(name)
rendered_template['spec']['storageClassName'] = "csi-cvmfs-{}"... | python | {
"resource": ""
} |
q8701 | render_cvmfs_sc | train | def render_cvmfs_sc(cvmfs_volume):
"""Render REANA_CVMFS_SC_TEMPLATE."""
name = CVMFS_REPOSITORIES[cvmfs_volume]
rendered_template = dict(REANA_CVMFS_SC_TEMPLATE)
rendered_template['metadata']['name'] = "csi-cvmfs-{}".format(name)
rendered_template['parameters']['repository'] = cvmfs_volume
retu... | python | {
"resource": ""
} |
q8702 | create_cvmfs_storage_class | train | def create_cvmfs_storage_class(cvmfs_volume):
"""Create CVMFS storage class."""
from kubernetes.client.rest import ApiException
from reana_commons.k8s.api_client import current_k8s_storagev1_api_client
try:
current_k8s_storagev1_api_client.\
create_storage_class(
ren... | python | {
"resource": ""
} |
q8703 | create_cvmfs_persistent_volume_claim | train | def create_cvmfs_persistent_volume_claim(cvmfs_volume):
"""Create CVMFS persistent volume claim."""
from kubernetes.client.rest import ApiException
from reana_commons.k8s.api_client import current_k8s_corev1_api_client
try:
current_k8s_corev1_api_client.\
create_namespaced_persisten... | python | {
"resource": ""
} |
q8704 | create_api_client | train | def create_api_client(api='BatchV1'):
"""Create Kubernetes API client using config.
:param api: String which represents which Kubernetes API to spawn. By
default BatchV1.
:returns: Kubernetes python client object for a specific API i.e. BatchV1.
"""
k8s_config.load_incluster_config()
ap... | python | {
"resource": ""
} |
q8705 | BasePublisher.__error_callback | train | def __error_callback(self, exception, interval):
"""Execute when there is an error while sending a message.
:param exception: Exception which has been thrown while trying to send
the message.
:param interval: Interval in which the message delivery will be
retried.
... | python | {
"resource": ""
} |
q8706 | BasePublisher._publish | train | def _publish(self, msg):
"""Publish, handling retries, a message in the queue.
:param msg: Object which represents the message to be sent in
the queue. Note that this object should be serializable in the
configured format (by default JSON).
"""
connection = self.... | python | {
"resource": ""
} |
q8707 | WorkflowStatusPublisher.publish_workflow_status | train | def publish_workflow_status(self, workflow_uuid, status,
logs='', message=None):
"""Publish workflow status using the configured.
:param workflow_uudid: String which represents the workflow UUID.
:param status: Integer which represents the status of the workflow,... | python | {
"resource": ""
} |
q8708 | WorkflowSubmissionPublisher.publish_workflow_submission | train | def publish_workflow_submission(self,
user_id,
workflow_id_or_name,
parameters):
"""Publish workflow submission parameters."""
msg = {
"user": user_id,
"workflow_id_or_name... | python | {
"resource": ""
} |
q8709 | serial_load | train | def serial_load(workflow_file, specification, parameters=None, original=None):
"""Validate and return a expanded REANA Serial workflow specification.
:param workflow_file: A specification file compliant with
REANA Serial workflow specification.
:returns: A dictionary which represents the valid Seri... | python | {
"resource": ""
} |
q8710 | _expand_parameters | train | def _expand_parameters(specification, parameters, original=None):
"""Expand parameters inside comands for Serial workflow specifications.
:param specification: Full valid Serial workflow specification.
:param parameters: Parameters to be extended on a Serial specification.
:param original: Flag which, ... | python | {
"resource": ""
} |
q8711 | reana_ready | train | def reana_ready():
"""Check if reana can start new workflows."""
from reana_commons.config import REANA_READY_CONDITIONS
for module_name, condition_list in REANA_READY_CONDITIONS.items():
for condition_name in condition_list:
module = importlib.import_module(module_name)
cond... | python | {
"resource": ""
} |
q8712 | check_predefined_conditions | train | def check_predefined_conditions():
"""Check k8s predefined conditions for the nodes."""
try:
node_info = current_k8s_corev1_api_client.list_node()
for node in node_info.items:
# check based on the predefined conditions about the
# node status: MemoryPressure, OutOfDisk, K... | python | {
"resource": ""
} |
q8713 | check_running_job_count | train | def check_running_job_count():
"""Check upper limit on running jobs."""
try:
job_list = current_k8s_batchv1_api_client.\
list_job_for_all_namespaces()
if len(job_list.items) > K8S_MAXIMUM_CONCURRENT_JOBS:
return False
except ApiException as e:
log.error('Somet... | python | {
"resource": ""
} |
q8714 | BaseAPIClient._get_spec | train | def _get_spec(self, spec_file):
"""Get json specification from package data."""
spec_file_path = os.path.join(
pkg_resources.
resource_filename(
'reana_commons',
'openapi_specifications'),
spec_file)
with open(spec_file_path) a... | python | {
"resource": ""
} |
q8715 | JobControllerAPIClient.submit | train | def submit(self,
workflow_uuid='',
experiment='',
image='',
cmd='',
prettified_cmd='',
workflow_workspace='',
job_name='',
cvmfs_mounts='false'):
"""Submit a job to RJC API.
:param na... | python | {
"resource": ""
} |
q8716 | JobControllerAPIClient.check_status | train | def check_status(self, job_id):
"""Check status of a job."""
response, http_response = self._client.jobs.get_job(job_id=job_id).\
result()
if http_response.status_code == 404:
raise HTTPNotFound('The given job ID was not found. Error: {}'.
f... | python | {
"resource": ""
} |
q8717 | JobControllerAPIClient.get_logs | train | def get_logs(self, job_id):
"""Get logs of a job."""
response, http_response = self._client.jobs.get_logs(job_id=job_id).\
result()
if http_response.status_code == 404:
raise HTTPNotFound('The given job ID was not found. Error: {}'.
format(h... | python | {
"resource": ""
} |
q8718 | JobControllerAPIClient.check_if_cached | train | def check_if_cached(self, job_spec, step, workflow_workspace):
"""Check if job result is in cache."""
response, http_response = self._client.job_cache.check_if_cached(
job_spec=json.dumps(job_spec),
workflow_json=json.dumps(step),
workflow_workspace=workflow_workspace... | python | {
"resource": ""
} |
q8719 | _logging_callback | train | def _logging_callback(level, domain, message, data):
""" Callback that outputs libgphoto2's logging message via
Python's standard logging facilities.
:param level: libgphoto2 logging level
:param domain: component the message originates from
:param message: logging message
:param data: ... | python | {
"resource": ""
} |
q8720 | Transfer.run | train | def run(self, name, cache_key,
local_path, remote_path,
local_options, remote_options, **kwargs):
"""
The main work horse of the transfer task. Calls the transfer
method with the local and remote storage backends as given
with the parameters.
:param name:... | python | {
"resource": ""
} |
q8721 | Transfer.transfer | train | def transfer(self, name, local, remote, **kwargs):
"""
Transfers the file with the given name from the local to the remote
storage backend.
:param name: The name of the file to transfer
:param local: The local storage backend instance
:param remote: The remote storage ba... | python | {
"resource": ""
} |
q8722 | get_string | train | def get_string(cfunc, *args):
""" Call a C function and return its return value as a Python string.
:param cfunc: C function to call
:param args: Arguments to call function with
:rtype: str
"""
cstr = get_ctype("const char**", cfunc, *args)
return backend.ffi.string(cstr).decod... | python | {
"resource": ""
} |
q8723 | get_ctype | train | def get_ctype(rtype, cfunc, *args):
""" Call a C function that takes a pointer as its last argument and
return the C object that it contains after the function has finished.
:param rtype: C data type is filled by the function
:param cfunc: C function to call
:param args: Arguments to cal... | python | {
"resource": ""
} |
q8724 | new_gp_object | train | def new_gp_object(typename):
""" Create an indirect pointer to a GPhoto2 type, call its matching
constructor function and return the pointer to it.
:param typename: Name of the type to create.
:return: A pointer to the specified data type.
"""
obj_p = backend.ffi.new("{0}**".f... | python | {
"resource": ""
} |
q8725 | get_library_version | train | def get_library_version():
""" Get the version number of the underlying gphoto2 library.
:return: The version
:rtype: tuple of (major, minor, patch) version numbers
"""
version_str = ffi.string(lib.gp_library_version(True)[0]).decode()
return tuple(int(x) for x in version_str.split('.')) | python | {
"resource": ""
} |
q8726 | list_cameras | train | def list_cameras():
""" List all attached USB cameras that are supported by libgphoto2.
:return: All recognized cameras
:rtype: list of :py:class:`Camera`
"""
ctx = lib.gp_context_new()
camlist_p = new_gp_object("CameraList")
port_list_p = new_gp_object("GPPortInfoList")
lib.gp_p... | python | {
"resource": ""
} |
q8727 | supported_cameras | train | def supported_cameras():
""" List the names of all cameras supported by libgphoto2, grouped by the
name of their driver.
"""
ctx = lib.gp_context_new()
abilities_list_p = new_gp_object("CameraAbilitiesList")
lib.gp_abilities_list_load(abilities_list_p, ctx)
abilities = ffi.new("CameraAbiliti... | python | {
"resource": ""
} |
q8728 | VideoCaptureContext.stop | train | def stop(self):
""" Stop the capture. """
self.camera._get_config()['actions']['movie'].set(False)
self.videofile = self.camera._wait_for_event(
event_type=lib.GP_EVENT_FILE_ADDED)
if self._old_captarget != "Memory card":
self.camera.config['settings']['capturetar... | python | {
"resource": ""
} |
q8729 | Directory.path | train | def path(self):
""" Absolute path to the directory on the camera's filesystem. """
if self.parent is None:
return "/"
else:
return os.path.join(self.parent.path, self.name) | python | {
"resource": ""
} |
q8730 | Directory.supported_operations | train | def supported_operations(self):
""" All directory operations supported by the camera. """
return tuple(op for op in backend.DIR_OPS if self._dir_ops & op) | python | {
"resource": ""
} |
q8731 | Directory.exists | train | def exists(self):
""" Check whether the directory exists on the camera. """
if self.name in ("", "/") and self.parent is None:
return True
else:
return self in self.parent.directories | python | {
"resource": ""
} |
q8732 | Directory.files | train | def files(self):
""" Get a generator that yields all files in the directory. """
filelist_p = new_gp_object("CameraList")
lib.gp_camera_folder_list_files(self._cam._cam, self.path.encode(),
filelist_p, self._cam._ctx)
for idx in range(lib.gp_list_c... | python | {
"resource": ""
} |
q8733 | Directory.directories | train | def directories(self):
""" Get a generator that yields all subdirectories in the directory.
"""
dirlist_p = new_gp_object("CameraList")
lib.gp_camera_folder_list_folders(self._cam._cam, self.path.encode(),
dirlist_p, self._cam._ctx)
for i... | python | {
"resource": ""
} |
q8734 | Directory.create | train | def create(self):
""" Create the directory. """
lib.gp_camera_folder_make_dir(
self._cam._cam, self.parent.path.encode(), self.name.encode(),
self._cam._ctx) | python | {
"resource": ""
} |
q8735 | Directory.remove | train | def remove(self):
""" Remove the directory. """
lib.gp_camera_folder_remove_dir(
self._cam._cam, self.parent.path.encode(), self.name.encode(),
self._cam._ctx) | python | {
"resource": ""
} |
q8736 | Directory.upload | train | def upload(self, local_path):
""" Upload a file to the camera's permanent storage.
:param local_path: Path to file to copy
:type local_path: str/unicode
"""
camerafile_p = ffi.new("CameraFile**")
with open(local_path, 'rb') as fp:
lib.gp_file_new_from_fd(cam... | python | {
"resource": ""
} |
q8737 | File.supported_operations | train | def supported_operations(self):
""" All file operations supported by the camera. """
return tuple(op for op in backend.FILE_OPS if self._operations & op) | python | {
"resource": ""
} |
q8738 | File.dimensions | train | def dimensions(self):
""" Dimensions of the image.
:rtype: :py:class:`ImageDimensions`
"""
return ImageDimensions(self._info.file.width, self._info.file.height) | python | {
"resource": ""
} |
q8739 | File.permissions | train | def permissions(self):
""" Permissions of the file.
Can be "r-" (read-only), "-w" (write-only), "rw" (read-write)
or "--" (no rights).
:rtype: str
"""
can_read = self._info.file.permissions & lib.GP_FILE_PERM_READ
can_write = self._info.file.permissions & lib.GP... | python | {
"resource": ""
} |
q8740 | File.save | train | def save(self, target_path, ftype='normal'):
""" Save file content to a local file.
:param target_path: Path to save remote file as.
:type target_path: str/unicode
:param ftype: Select 'view' on file.
:type ftype: str
"""
camfile_p = ffi.new("Camera... | python | {
"resource": ""
} |
q8741 | File.get_data | train | def get_data(self, ftype='normal'):
""" Get file content as a bytestring.
:param ftype: Select 'view' on file.
:type ftype: str
:return: File content
:rtype: bytes
"""
camfile_p = ffi.new("CameraFile**")
lib.gp_file_new... | python | {
"resource": ""
} |
q8742 | File.iter_data | train | def iter_data(self, chunk_size=2**16, ftype='normal'):
""" Get an iterator that yields chunks of the file content.
:param chunk_size: Size of yielded chunks in bytes
:type chunk_size: int
:param ftype: Select 'view' on file.
:type ftype: str
:return: ... | python | {
"resource": ""
} |
q8743 | File.remove | train | def remove(self):
""" Remove file from device. """
lib.gp_camera_file_delete(self._cam._cam, self.directory.path.encode(),
self.name.encode(), self._cam._ctx) | python | {
"resource": ""
} |
q8744 | ConfigItem.set | train | def set(self, value):
""" Update value of the option.
Only possible for options with :py:attr:`readonly` set to `False`.
If :py:attr:`type` is `choice`, the value must be one of the
:py:attr:`choices`.
If :py:attr:`type` is `range`, the value must be in the range
describ... | python | {
"resource": ""
} |
q8745 | Camera.supported_operations | train | def supported_operations(self):
""" All operations supported by the camera. """
return tuple(op for op in backend.CAM_OPS
if self._abilities.operations & op) | python | {
"resource": ""
} |
q8746 | Camera.usb_info | train | def usb_info(self):
""" The camera's USB information. """
return UsbInformation(self._abilities.usb_vendor,
self._abilities.usb_product,
self._abilities.usb_class,
self._abilities.usb_subclass,
... | python | {
"resource": ""
} |
q8747 | Camera.config | train | def config(self):
""" Writeable configuration parameters.
:rtype: dict
"""
config = self._get_config()
return {section: {itm.name: itm for itm in config[section].values()
if not itm.readonly}
for section in config
if ... | python | {
"resource": ""
} |
q8748 | Camera.storage_info | train | def storage_info(self):
""" Information about the camera's storage. """
info_p = ffi.new("CameraStorageInformation**")
num_info_p = ffi.new("int*")
lib.gp_camera_get_storageinfo(self._cam, info_p, num_info_p, self._ctx)
infos = []
for idx in range(num_info_p[0]):
... | python | {
"resource": ""
} |
q8749 | Camera.list_all_files | train | def list_all_files(self):
""" Utility method that yields all files on the device's file
systems.
"""
def list_files_recursively(directory):
f_gen = itertools.chain(
directory.files,
*tuple(list_files_recursively(d)
fo... | python | {
"resource": ""
} |
q8750 | Camera.list_all_directories | train | def list_all_directories(self):
""" Utility method that yields all directories on the device's file
systems.
"""
def list_dirs_recursively(directory):
if directory == self.filesystem:
yield directory
d_gen = itertools.chain(
dir... | python | {
"resource": ""
} |
q8751 | Camera.capture | train | def capture(self, to_camera_storage=False):
""" Capture an image.
Some cameras (mostly Canon and Nikon) support capturing to internal
RAM. On these devices, you have to specify `to_camera_storage` if
you want to save the images to the memory card. On devices that
do not support ... | python | {
"resource": ""
} |
q8752 | Camera.capture_video | train | def capture_video(self, length):
""" Capture a video.
This always writes to the memory card, since internal RAM is likely
to run out of space very quickly.
Currently this only works with Nikon cameras.
:param length: Length of the video to capture in seconds.
:typ... | python | {
"resource": ""
} |
q8753 | Camera.get_preview | train | def get_preview(self):
""" Get a preview from the camera's viewport.
This will usually be a JPEG image with the dimensions depending on
the camera. You will need to call the exit() method manually after
you are done capturing a live preview.
:return: The preview image as a ... | python | {
"resource": ""
} |
q8754 | QueuedStorage.transfer | train | def transfer(self, name, cache_key=None):
"""
Transfers the file with the given name to the remote storage
backend by queuing the task.
:param name: file name
:type name: str
:param cache_key: the cache key to set after a successful task run
:type cache_key: str
... | python | {
"resource": ""
} |
q8755 | QueuedStorage.get_available_name | train | def get_available_name(self, name):
"""
Returns a filename that's free on both the local and remote storage
systems, and available for new content to be written to.
:param name: file name
:type name: str
:rtype: str
"""
local_available_name = self.local.g... | python | {
"resource": ""
} |
q8756 | QueryAnalyzer.generate_query_report | train | def generate_query_report(self, db_uri, parsed_query, db_name, collection_name):
"""Generates a comprehensive report on the raw query"""
index_analysis = None
recommendation = None
namespace = parsed_query['ns']
indexStatus = "unknown"
index_cache_entry = self._ensure_in... | python | {
"resource": ""
} |
q8757 | QueryAnalyzer._ensure_index_cache | train | def _ensure_index_cache(self, db_uri, db_name, collection_name):
"""Adds a collections index entries to the cache if not present"""
if not self._check_indexes or db_uri is None:
return {'indexes': None}
if db_name not in self.get_cache():
self._internal_map[db_name] = {}
... | python | {
"resource": ""
} |
q8758 | QueryAnalyzer._generate_query_analysis | train | def _generate_query_analysis(self, parsed_query, db_name, collection_name):
"""Translates a raw query object into a Dex query analysis"""
analyzed_fields = []
field_count = 0
supported = True
sort_fields = []
query_mask = None
if 'command' in parsed_query and pa... | python | {
"resource": ""
} |
q8759 | QueryAnalyzer._generate_index_analysis | train | def _generate_index_analysis(self, query_analysis, indexes):
"""Compares a query signature to the index cache to identify complete
and partial indexes available to the query"""
needs_recommendation = True
full_indexes = []
partial_indexes = []
coverage = "unknown"
... | python | {
"resource": ""
} |
q8760 | QueryAnalyzer._generate_index_report | train | def _generate_index_report(self, index, query_analysis):
"""Analyzes an existing index against the results of query analysis"""
all_fields = []
equiv_fields = []
sort_fields = []
range_fields = []
for query_field in query_analysis['analyzedFields']:
all_fiel... | python | {
"resource": ""
} |
q8761 | QueryAnalyzer._generate_recommendation | train | def _generate_recommendation(self,
query_analysis,
db_name,
collection_name):
"""Generates an ideal query recommendation"""
index_rec = '{'
for query_field in query_analysis['analyzedFields']:
... | python | {
"resource": ""
} |
q8762 | ReportAggregation.add_query_occurrence | train | def add_query_occurrence(self, report):
"""Adds a report to the report aggregation"""
initial_millis = int(report['parsed']['stats']['millis'])
mask = report['queryMask']
existing_report = self._get_existing_report(mask, report)
if existing_report is not None:
self... | python | {
"resource": ""
} |
q8763 | ReportAggregation.get_reports | train | def get_reports(self):
"""Returns a minimized version of the aggregation"""
return sorted(self._reports,
key=lambda x: x['stats']['totalTimeMillis'],
reverse=True) | python | {
"resource": ""
} |
q8764 | ReportAggregation._get_existing_report | train | def _get_existing_report(self, mask, report):
"""Returns the aggregated report that matches report"""
for existing_report in self._reports:
if existing_report['namespace'] == report['namespace']:
if mask == existing_report['queryMask']:
return existing_rep... | python | {
"resource": ""
} |
q8765 | ReportAggregation._merge_report | train | def _merge_report(self, target, new):
"""Merges a new report into the target report"""
time = None
if 'ts' in new['parsed']:
time = new['parsed']['ts']
if (target.get('lastSeenDate', None) and
time and
target['lastSeenDate'] < time):
... | python | {
"resource": ""
} |
q8766 | Parser.parse | train | def parse(self, input):
"""Passes input to each QueryLineHandler in use"""
query = None
for handler in self._line_handlers:
try:
query = handler.handle(input)
except Exception as e:
query = None
finally:
if query... | python | {
"resource": ""
} |
q8767 | Dex.generate_query_report | train | def generate_query_report(self, db_uri, query, db_name, collection_name):
"""Analyzes a single query"""
return self._query_analyzer.generate_query_report(db_uri,
query,
db_name,
... | python | {
"resource": ""
} |
q8768 | Dex.watch_logfile | train | def watch_logfile(self, logfile_path):
"""Analyzes queries from the tail of a given log file"""
self._run_stats['logSource'] = logfile_path
log_parser = LogParser()
# For each new line in the logfile ...
output_time = time.time() + WATCH_DISPLAY_REFRESH_SECONDS
try:
... | python | {
"resource": ""
} |
q8769 | Dex._tail_file | train | def _tail_file(self, file, interval):
"""Tails a file"""
file.seek(0,2)
while True:
where = file.tell()
line = file.readline()
if not line:
time.sleep(interval)
file.seek(where)
else:
yield line | python | {
"resource": ""
} |
q8770 | Dex._tail_profile | train | def _tail_profile(self, db, interval):
"""Tails the system.profile collection"""
latest_doc = None
while latest_doc is None:
time.sleep(interval)
latest_doc = db['system.profile'].find_one()
current_time = latest_doc['ts']
while True:
time.sl... | python | {
"resource": ""
} |
q8771 | Dex._tuplefy_namespace | train | def _tuplefy_namespace(self, namespace):
"""Converts a mongodb namespace to a db, collection tuple"""
namespace_split = namespace.split('.', 1)
if len(namespace_split) is 1:
# we treat a single element as a collection name.
# this also properly tuplefies '*'
n... | python | {
"resource": ""
} |
q8772 | Dex._validate_namespaces | train | def _validate_namespaces(self, input_namespaces):
"""Converts a list of db namespaces to a list of namespace tuples,
supporting basic commandline wildcards"""
output_namespaces = []
if input_namespaces == []:
return output_namespaces
elif '*' in input_namespaces:
... | python | {
"resource": ""
} |
q8773 | Dex._namespace_requested | train | def _namespace_requested(self, namespace):
"""Checks whether the requested_namespaces contain the provided
namespace"""
if namespace is None:
return False
namespace_tuple = self._tuplefy_namespace(namespace)
if namespace_tuple[0] in IGNORE_DBS:
return ... | python | {
"resource": ""
} |
q8774 | Dex._tuple_requested | train | def _tuple_requested(self, namespace_tuple):
"""Helper for _namespace_requested. Supports limited wildcards"""
if not isinstance(namespace_tuple[0], unicode):
encoded_db = unicode(namespace_tuple[0])
else:
encoded_db = namespace_tuple[0]
if not isinstance(namespac... | python | {
"resource": ""
} |
q8775 | Dex._get_requested_databases | train | def _get_requested_databases(self):
"""Returns a list of databases requested, not including ignored dbs"""
requested_databases = []
if ((self._requested_namespaces is not None) and
(self._requested_namespaces != [])):
for requested_namespace in self._requested_namespa... | python | {
"resource": ""
} |
q8776 | FortiOSDriver.get_config | train | def get_config(self, retrieve="all"):
"""get_config implementation for FortiOS."""
get_startup = retrieve == "all" or retrieve == "startup"
get_running = retrieve == "all" or retrieve == "running"
get_candidate = retrieve == "all" or retrieve == "candidate"
if retrieve == "all" ... | python | {
"resource": ""
} |
q8777 | DelugeRPCClient.connect | train | def connect(self):
"""
Connects to the Deluge instance
"""
self._connect()
logger.debug('Connected to Deluge, detecting daemon version')
self._detect_deluge_version()
logger.debug('Daemon version {} detected, logging in'.format(self.deluge_version))
if sel... | python | {
"resource": ""
} |
q8778 | DelugeRPCClient.disconnect | train | def disconnect(self):
"""
Disconnect from deluge
"""
if self.connected:
self._socket.close()
self._socket = None
self.connected = False | python | {
"resource": ""
} |
q8779 | DelugeRPCClient.call | train | def call(self, method, *args, **kwargs):
"""
Calls an RPC function
"""
tried_reconnect = False
for _ in range(2):
try:
self._send_call(self.deluge_version, self.deluge_protocol_version, method, *args, **kwargs)
return self._receive_resp... | python | {
"resource": ""
} |
q8780 | StickerSet.to_array | train | def to_array(self):
"""
Serializes this StickerSet to a dictionary.
:return: dictionary representation of this object.
:rtype: dict
"""
array = super(StickerSet, self).to_array()
array['name'] = u(self.name) # py2: type unicode, py3: type str
array['tit... | python | {
"resource": ""
} |
q8781 | StickerSet.from_array | train | def from_array(array):
"""
Deserialize a new StickerSet from a given dictionary.
:return: new StickerSet instance.
:rtype: StickerSet
"""
if array is None or not array:
return None
# end if
assert_type_or_raise(array, dict, parameter_name="arr... | python | {
"resource": ""
} |
q8782 | MaskPosition.to_array | train | def to_array(self):
"""
Serializes this MaskPosition to a dictionary.
:return: dictionary representation of this object.
:rtype: dict
"""
array = super(MaskPosition, self).to_array()
array['point'] = u(self.point) # py2: type unicode, py3: type str
arra... | python | {
"resource": ""
} |
q8783 | MaskPosition.from_array | train | def from_array(array):
"""
Deserialize a new MaskPosition from a given dictionary.
:return: new MaskPosition instance.
:rtype: MaskPosition
"""
if array is None or not array:
return None
# end if
assert_type_or_raise(array, dict, parameter_nam... | python | {
"resource": ""
} |
q8784 | compile | train | def compile(cfg_path, out_path, executable=None, env=None, log=None):
"""
Use ACE to compile a grammar.
Args:
cfg_path (str): the path to the ACE config file
out_path (str): the path where the compiled grammar will be
written
executable (str, optional): the path to the A... | python | {
"resource": ""
} |
q8785 | AceProcess.close | train | def close(self):
"""
Close the ACE process and return the process's exit code.
"""
self.run_info['end'] = datetime.now()
self._p.stdin.close()
for line in self._p.stdout:
if line.startswith('NOTE: tsdb run:'):
self._read_run_info(line)
... | python | {
"resource": ""
} |
q8786 | loads | train | def loads(s, single=False):
"""
Deserialize DMRX string representations
Args:
s (str): a DMRX string
single (bool): if `True`, only return the first Xmrs object
Returns:
a generator of Xmrs objects (unless *single* is `True`)
"""
corpus = etree.fromstring(s)
if singl... | python | {
"resource": ""
} |
q8787 | ParseResult.derivation | train | def derivation(self):
"""
Deserialize and return a Derivation object for UDF- or
JSON-formatted derivation data; otherwise return the original
string.
"""
drv = self.get('derivation')
if drv is not None:
if isinstance(drv, dict):
drv = ... | python | {
"resource": ""
} |
q8788 | ParseResult.tree | train | def tree(self):
"""
Deserialize and return a labeled syntax tree. The tree data
may be a standalone datum, or embedded in the derivation.
"""
tree = self.get('tree')
if isinstance(tree, stringtypes):
tree = SExpr.parse(tree).data
elif tree is None:
... | python | {
"resource": ""
} |
q8789 | ParseResult.mrs | train | def mrs(self):
"""
Deserialize and return an Mrs object for simplemrs or
JSON-formatted MRS data; otherwise return the original string.
"""
mrs = self.get('mrs')
if mrs is not None:
if isinstance(mrs, dict):
mrs = Mrs.from_dict(mrs)
... | python | {
"resource": ""
} |
q8790 | ParseResult.eds | train | def eds(self):
"""
Deserialize and return an Eds object for native- or
JSON-formatted EDS data; otherwise return the original string.
"""
_eds = self.get('eds')
if _eds is not None:
if isinstance(_eds, dict):
_eds = eds.Eds.from_dict(_eds)
... | python | {
"resource": ""
} |
q8791 | ParseResult.dmrs | train | def dmrs(self):
"""
Deserialize and return a Dmrs object for JSON-formatted DMRS
data; otherwise return the original string.
"""
dmrs = self.get('dmrs')
if dmrs is not None:
if isinstance(dmrs, dict):
dmrs = Dmrs.from_dict(dmrs)
return ... | python | {
"resource": ""
} |
q8792 | ParseResponse.tokens | train | def tokens(self, tokenset='internal'):
"""
Deserialize and return a YyTokenLattice object for the
initial or internal token set, if provided, from the YY
format or the JSON-formatted data; otherwise return the
original string.
Args:
tokenset (str): return `'i... | python | {
"resource": ""
} |
q8793 | GameHighScore.to_array | train | def to_array(self):
"""
Serializes this GameHighScore to a dictionary.
:return: dictionary representation of this object.
:rtype: dict
"""
array = super(GameHighScore, self).to_array()
array['position'] = int(self.position) # type int
array['user'] = sel... | python | {
"resource": ""
} |
q8794 | GameHighScore.from_array | train | def from_array(array):
"""
Deserialize a new GameHighScore from a given dictionary.
:return: new GameHighScore instance.
:rtype: GameHighScore
"""
if array is None or not array:
return None
# end if
assert_type_or_raise(array, dict, parameter_... | python | {
"resource": ""
} |
q8795 | valuemap | train | def valuemap(f):
"""
Decorator to help PEG functions handle value conversions.
"""
@wraps(f)
def wrapper(*args, **kwargs):
if 'value' in kwargs:
val = kwargs['value']
del kwargs['value']
_f = f(*args, **kwargs)
def valued_f(*args, **kwargs):
... | python | {
"resource": ""
} |
q8796 | literal | train | def literal(x):
"""
Create a PEG function to consume a literal.
"""
xlen = len(x)
msg = 'Expected: "{}"'.format(x)
def match_literal(s, grm=None, pos=0):
if s[:xlen] == x:
return PegreResult(s[xlen:], x, (pos, pos+xlen))
raise PegreError(msg, pos)
return match_lit... | python | {
"resource": ""
} |
q8797 | regex | train | def regex(r):
"""
Create a PEG function to match a regular expression.
"""
if isinstance(r, stringtypes):
p = re.compile(r)
else:
p = r
msg = 'Expected to match: {}'.format(p.pattern)
def match_regex(s, grm=None, pos=0):
m = p.match(s)
if m is not None:
... | python | {
"resource": ""
} |
q8798 | nonterminal | train | def nonterminal(n):
"""
Create a PEG function to match a nonterminal.
"""
def match_nonterminal(s, grm=None, pos=0):
if grm is None: grm = {}
expr = grm[n]
return expr(s, grm, pos)
return match_nonterminal | python | {
"resource": ""
} |
q8799 | and_next | train | def and_next(e):
"""
Create a PEG function for positive lookahead.
"""
def match_and_next(s, grm=None, pos=0):
try:
e(s, grm, pos)
except PegreError as ex:
raise PegreError('Positive lookahead failed', pos)
else:
return PegreResult(s, Ignore, (... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.