_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q273700 | Kernel.iteration_length | test | def iteration_length(self, dimension=None):
"""
Return the number of global loop iterations that are performed.
If dimension is not None, it is the loop dimension that is returned
(-1 is the inner most loop and 0 the outermost)
"""
total_length = 1
if dimension ... | python | {
"resource": ""
} |
q273701 | Kernel.get_loop_stack | test | def get_loop_stack(self, subs_consts=False):
"""Yield loop stack dictionaries in order from outer to inner."""
for l in self._loop_stack:
if subs_consts:
yield {'index': l[0],
'start': self.subs_consts(l[1]),
'stop': self.subs_con... | python | {
"resource": ""
} |
q273702 | Kernel.index_order | test | def index_order(self, sources=True, destinations=True):
"""
Return the order of indices as they appear in array references.
Use *source* and *destination* to filter output
"""
if sources:
arefs = chain(*self.sources.values())
else:
arefs = []
... | python | {
"resource": ""
} |
q273703 | Kernel.compile_sympy_accesses | test | def compile_sympy_accesses(self, sources=True, destinations=True):
"""
Return a dictionary of lists of sympy accesses, for each variable.
Use *source* and *destination* to filter output
"""
sympy_accesses = defaultdict(list)
# Compile sympy accesses
for var_name ... | python | {
"resource": ""
} |
q273704 | Kernel.compile_relative_distances | test | def compile_relative_distances(self, sympy_accesses=None):
"""
Return load and store distances between accesses.
:param sympy_accesses: optionally restrict accesses, default from compile_sympy_accesses()
e.g. if accesses are to [+N, +1, -1, -N], relative distances are [N-1, 2, N-1]
... | python | {
"resource": ""
} |
q273705 | Kernel.global_iterator_to_indices | test | def global_iterator_to_indices(self, git=None):
"""
Return sympy expressions translating global_iterator to loop indices.
If global_iterator is given, an integer is returned
"""
# unwind global iteration count into loop counters:
base_loop_counters = {}
global_it... | python | {
"resource": ""
} |
q273706 | Kernel.global_iterator | test | def global_iterator(self):
"""
Return global iterator sympy expression
"""
global_iterator = sympy.Integer(0)
total_length = sympy.Integer(1)
for var_name, start, end, incr in reversed(self._loop_stack):
loop_var = symbol_pos_int(var_name)
length =... | python | {
"resource": ""
} |
q273707 | Kernel.indices_to_global_iterator | test | def indices_to_global_iterator(self, indices):
"""
Transform a dictionary of indices to a global iterator integer.
Inverse of global_iterator_to_indices().
"""
global_iterator = self.subs_consts(self.global_iterator().subs(indices))
return global_iterator | python | {
"resource": ""
} |
q273708 | Kernel.max_global_iteration | test | def max_global_iteration(self):
"""Return global iterator with last iteration number"""
return self.indices_to_global_iterator({
symbol_pos_int(var_name): end-1 for var_name, start, end, incr in self._loop_stack
}) | python | {
"resource": ""
} |
q273709 | Kernel.print_kernel_info | test | def print_kernel_info(self, output_file=sys.stdout):
"""Print kernel information in human readble format."""
table = (' idx | min max step\n' +
'---------+---------------------------------\n')
for l in self._loop_stack:
table += '{:>8} | {!r:>... | python | {
"resource": ""
} |
q273710 | Kernel.print_variables_info | test | def print_variables_info(self, output_file=sys.stdout):
"""Print variables information in human readble format."""
table = (' name | type size \n' +
'---------+-------------------------\n')
for name, var_info in list(self.variables.items()):
table +=... | python | {
"resource": ""
} |
q273711 | Kernel.print_constants_info | test | def print_constants_info(self, output_file=sys.stdout):
"""Print constants information in human readble format."""
table = (' name | value \n' +
'---------+-----------\n')
for name, value in list(self.constants.items()):
table += '{!s:>8} | {:<10}\n'.format(na... | python | {
"resource": ""
} |
q273712 | KernelCode.print_kernel_code | test | def print_kernel_code(self, output_file=sys.stdout):
"""Print source code of kernel."""
print(self.kernel_code, file=output_file) | python | {
"resource": ""
} |
q273713 | KernelCode.conv_ast_to_sym | test | def conv_ast_to_sym(self, math_ast):
"""
Convert mathematical expressions to a sympy representation.
May only contain paranthesis, addition, subtraction and multiplication from AST.
"""
if type(math_ast) is c_ast.ID:
return symbol_pos_int(math_ast.name)
elif ... | python | {
"resource": ""
} |
q273714 | KernelCode._get_offsets | test | def _get_offsets(self, aref, dim=0):
"""
Return a tuple of offsets of an ArrayRef object in all dimensions.
The index order is right to left (c-code order).
e.g. c[i+1][j-2] -> (-2, +1)
If aref is actually a c_ast.ID, None will be returned.
"""
if isinstance(are... | python | {
"resource": ""
} |
q273715 | KernelCode._get_basename | test | def _get_basename(cls, aref):
"""
Return base name of ArrayRef object.
e.g. c[i+1][j-2] -> 'c'
"""
if isinstance(aref.name, c_ast.ArrayRef):
return cls._get_basename(aref.name)
elif isinstance(aref.name, str):
return aref.name
else:
... | python | {
"resource": ""
} |
q273716 | KernelCode.get_index_type | test | def get_index_type(self, loop_nest=None):
"""
Return index type used in loop nest.
If index type between loops differ, an exception is raised.
"""
if loop_nest is None:
loop_nest = self.get_kernel_loop_nest()
if type(loop_nest) is c_ast.For:
loop_... | python | {
"resource": ""
} |
q273717 | KernelCode._build_const_declartions | test | def _build_const_declartions(self, with_init=True):
"""
Generate constants declarations
:return: list of declarations
"""
decls = []
# Use type as provided by user in loop indices
index_type = self.get_index_type()
i = 2 # subscript for cli input, 1 is... | python | {
"resource": ""
} |
q273718 | KernelCode.get_array_declarations | test | def get_array_declarations(self):
"""Return array declarations."""
return [d for d in self.kernel_ast.block_items
if type(d) is c_ast.Decl and type(d.type) is c_ast.ArrayDecl] | python | {
"resource": ""
} |
q273719 | KernelCode.get_kernel_loop_nest | test | def get_kernel_loop_nest(self):
"""Return kernel loop nest including any preceding pragmas and following swaps."""
loop_nest = [s for s in self.kernel_ast.block_items
if type(s) in [c_ast.For, c_ast.Pragma, c_ast.FuncCall]]
assert len(loop_nest) >= 1, "Found to few for state... | python | {
"resource": ""
} |
q273720 | KernelCode._build_array_declarations | test | def _build_array_declarations(self, with_init=True):
"""
Generate declaration statements for arrays.
Also transforming multi-dim to 1d arrays and initializing with malloc.
:param with_init: ommit malloc initialization
:return: list of declarations nodes, dictionary of array na... | python | {
"resource": ""
} |
q273721 | KernelCode._find_inner_most_loop | test | def _find_inner_most_loop(self, loop_nest):
"""Return inner most for loop in loop nest"""
r = None
for s in loop_nest:
if type(s) is c_ast.For:
return self._find_inner_most_loop(s) or s
else:
r = r or self._find_inner_most_loop(s)
r... | python | {
"resource": ""
} |
q273722 | KernelCode._build_array_initializations | test | def _build_array_initializations(self, array_dimensions):
"""
Generate initialization statements for arrays.
:param array_dimensions: dictionary of array dimensions
:return: list of nodes
"""
kernel = deepcopy(deepcopy(self.get_kernel_loop_nest()))
# traverse to... | python | {
"resource": ""
} |
q273723 | KernelCode._build_dummy_calls | test | def _build_dummy_calls(self):
"""
Generate false if branch with dummy calls
Requires kerncraft.h to be included, which defines dummy(...) and var_false.
:return: dummy statement
"""
# Make sure nothing gets removed by inserting dummy calls
dummy_calls = []
... | python | {
"resource": ""
} |
q273724 | KernelCode._build_kernel_function_declaration | test | def _build_kernel_function_declaration(self, name='kernel'):
"""Build and return kernel function declaration"""
array_declarations, array_dimensions = self._build_array_declarations(with_init=False)
scalar_declarations = self._build_scalar_declarations(with_init=False)
const_declarations... | python | {
"resource": ""
} |
q273725 | KernelCode._build_scalar_declarations | test | def _build_scalar_declarations(self, with_init=True):
"""Build and return scalar variable declarations"""
# copy scalar declarations from from kernel ast
scalar_declarations = [deepcopy(d) for d in self.kernel_ast.block_items
if type(d) is c_ast.Decl and type(d.typ... | python | {
"resource": ""
} |
q273726 | KernelCode.get_kernel_code | test | def get_kernel_code(self, openmp=False, as_filename=False, name='kernel'):
"""
Generate and return compilable source code with kernel function from AST.
:param openmp: if true, OpenMP code will be generated
:param as_filename: if true, will save to file and return filename
:para... | python | {
"resource": ""
} |
q273727 | KernelCode._build_kernel_call | test | def _build_kernel_call(self, name='kernel'):
"""Generate and return kernel call ast."""
return c_ast.FuncCall(name=c_ast.ID(name=name), args=c_ast.ExprList(exprs=[
c_ast.ID(name=d.name) for d in (
self._build_array_declarations()[0] +
self._build_scala... | python | {
"resource": ""
} |
q273728 | KernelCode.get_main_code | test | def get_main_code(self, as_filename=False, kernel_function_name='kernel'):
"""
Generate and return compilable source code from AST.
"""
# TODO produce nicer code, including help text and other "comfort features".
assert self.kernel_ast is not None, "AST does not exist, this could... | python | {
"resource": ""
} |
q273729 | KernelCode.iaca_analysis | test | def iaca_analysis(self, micro_architecture, asm_block='auto',
pointer_increment='auto_with_manual_fallback', verbose=False):
"""
Run an IACA analysis and return its outcome.
*asm_block* controls how the to-be-marked block is chosen. "auto" (default) results in
the ... | python | {
"resource": ""
} |
q273730 | KernelCode.build_executable | test | def build_executable(self, lflags=None, verbose=False, openmp=False):
"""Compile source to executable with likwid capabilities and return the executable name."""
compiler, compiler_args = self._machine.get_compiler()
kernel_obj_filename = self.compile_kernel(openmp=openmp, verbose=verbose)
... | python | {
"resource": ""
} |
q273731 | KernelDescription.string_to_sympy | test | def string_to_sympy(cls, s):
"""Convert any string to a sympy object or None."""
if isinstance(s, int):
return sympy.Integer(s)
elif isinstance(s, list):
return tuple([cls.string_to_sympy(e) for e in s])
elif s is None:
return None
else:
... | python | {
"resource": ""
} |
q273732 | MachineModel.get_identifier | test | def get_identifier(self):
"""Return identifier which is either the machine file name or sha256 checksum of data."""
if self._path:
return os.path.basename(self._path)
else:
return hashlib.sha256(hashlib.sha256(repr(self._data).encode())).hexdigest() | python | {
"resource": ""
} |
q273733 | MachineModel.get_last_modified_datetime | test | def get_last_modified_datetime(self):
"""Return datetime object of modified time of machine file. Return now if not a file."""
if self._path:
statbuf = os.stat(self._path)
return datetime.utcfromtimestamp(statbuf.st_mtime)
else:
return datetime.now() | python | {
"resource": ""
} |
q273734 | MachineModel.get_cachesim | test | def get_cachesim(self, cores=1):
"""
Return a cachesim.CacheSimulator object based on the machine description.
:param cores: core count (default: 1)
"""
cache_dict = {}
for c in self['memory hierarchy']:
# Skip main memory
if 'cache per group' not... | python | {
"resource": ""
} |
q273735 | MachineModel.get_bandwidth | test | def get_bandwidth(self, cache_level, read_streams, write_streams, threads_per_core, cores=None):
"""
Return best fitting bandwidth according to number of threads, read and write streams.
:param cache_level: integer of cache (0 is L1, 1 is L2 ...)
:param read_streams: number of read stre... | python | {
"resource": ""
} |
q273736 | MachineModel.get_compiler | test | def get_compiler(self, compiler=None, flags=None):
"""
Return tuple of compiler and compiler flags.
Selects compiler and flags from machine description file, commandline arguments or call
arguements.
"""
if self._args:
compiler = compiler or self._args.compil... | python | {
"resource": ""
} |
q273737 | MachineModel.parse_perfctr_event | test | def parse_perfctr_event(perfctr):
"""
Parse events in machine description to tuple representation used in Benchmark module.
Examples:
>>> parse_perfctr_event('PERF_EVENT:REG[0-3]')
('PERF_EVENT', 'REG[0-3]')
>>> parse_perfctr_event('PERF_EVENT:REG[0-3]:STAY:FOO=23:BAR=0x... | python | {
"resource": ""
} |
q273738 | Intervals._enforce_no_overlap | test | def _enforce_no_overlap(self, start_at=0):
"""Enforce that no ranges overlap in internal storage."""
i = start_at
while i+1 < len(self.data):
if self.data[i][1] >= self.data[i+1][0]:
# beginning of i+1-th range is contained in i-th range
if self.data[i... | python | {
"resource": ""
} |
q273739 | get_header_path | test | def get_header_path() -> str:
"""Return local folder path of header files."""
import os
return os.path.abspath(os.path.dirname(os.path.realpath(__file__))) + '/headers/' | python | {
"resource": ""
} |
q273740 | CacheSimulationPredictor._align_iteration_with_cl_boundary | test | def _align_iteration_with_cl_boundary(self, iteration, subtract=True):
"""Align iteration with cacheline boundary."""
# FIXME handle multiple datatypes
element_size = self.kernel.datatypes_size[self.kernel.datatype]
cacheline_size = self.machine['cacheline size']
elements_per_cac... | python | {
"resource": ""
} |
q273741 | CacheSimulationPredictor.get_loads | test | def get_loads(self):
"""Return a list with number of loaded cache lines per memory hierarchy level."""
return [self.stats[cache_level]['LOAD_count'] / self.first_dim_factor
for cache_level in range(len(self.machine['memory hierarchy']))] | python | {
"resource": ""
} |
q273742 | CacheSimulationPredictor.get_hits | test | def get_hits(self):
"""Return a list with number of hit cache lines per memory hierarchy level."""
return [self.stats[cache_level]['HIT_count']/self.first_dim_factor
for cache_level in range(len(self.machine['memory hierarchy']))] | python | {
"resource": ""
} |
q273743 | CacheSimulationPredictor.get_misses | test | def get_misses(self):
"""Return a list with number of missed cache lines per memory hierarchy level."""
return [self.stats[cache_level]['MISS_count']/self.first_dim_factor
for cache_level in range(len(self.machine['memory hierarchy']))] | python | {
"resource": ""
} |
q273744 | CacheSimulationPredictor.get_stores | test | def get_stores(self):
"""Return a list with number of stored cache lines per memory hierarchy level."""
return [self.stats[cache_level]['STORE_count']/self.first_dim_factor
for cache_level in range(len(self.machine['memory hierarchy']))] | python | {
"resource": ""
} |
q273745 | CacheSimulationPredictor.get_evicts | test | def get_evicts(self):
"""Return a list with number of evicted cache lines per memory hierarchy level."""
return [self.stats[cache_level]['EVICT_count']/self.first_dim_factor
for cache_level in range(len(self.machine['memory hierarchy']))] | python | {
"resource": ""
} |
q273746 | CacheSimulationPredictor.get_infos | test | def get_infos(self):
"""Return verbose information about the predictor."""
first_dim_factor = self.first_dim_factor
infos = {'memory hierarchy': [], 'cache stats': self.stats,
'cachelines in stats': first_dim_factor}
for cache_level, cache_info in list(enumerate(self.mac... | python | {
"resource": ""
} |
q273747 | fix_env_variable | test | def fix_env_variable(name, value):
"""Fix environment variable to a value within context. Unset if value is None."""
orig = os.environ.get(name, None)
if value is not None:
# Set if value is not None
os.environ[name] = value
elif name in os.environ:
# Unset if value is None
... | python | {
"resource": ""
} |
q273748 | Benchmark.configure_arggroup | test | def configure_arggroup(cls, parser):
"""Configure argument parser."""
parser.add_argument(
'--no-phenoecm', action='store_true',
help='Disables the phenomenological ECM model building.')
parser.add_argument(
'--iterations', type=int, default=10,
he... | python | {
"resource": ""
} |
q273749 | Benchmark.report | test | def report(self, output_file=sys.stdout):
"""Report gathered analysis data in human readable form."""
if self.verbose > 1:
with pprint_nosort():
pprint.pprint(self.results)
if self.verbose > 0:
print('Runtime (per repetition): {:.2g} s'.format(
... | python | {
"resource": ""
} |
q273750 | parse_description | test | def parse_description():
"""
Parse the description in the README file
CommandLine:
python -c "import setup; print(setup.parse_description())"
"""
from os.path import dirname, join, exists
readme_fpath = join(dirname(__file__), 'README.md')
# print('readme_fpath = %r' % (readme_fpath... | python | {
"resource": ""
} |
q273751 | schedule_retry | test | def schedule_retry(self, config):
"""Schedule a retry"""
raise self.retry(countdown=config.get('SAILTHRU_RETRY_SECONDS'),
max_retries=config.get('SAILTHRU_RETRY_ATTEMPTS')) | python | {
"resource": ""
} |
q273752 | _build_purchase_item | test | def _build_purchase_item(course_id, course_url, cost_in_cents, mode, course_data, sku):
"""Build and return Sailthru purchase item object"""
# build item description
item = {
'id': "{}-{}".format(course_id, mode),
'url': course_url,
'price': cost_in_cents,
'qty': 1,
}
... | python | {
"resource": ""
} |
q273753 | _record_purchase | test | def _record_purchase(sailthru_client, email, item, purchase_incomplete, message_id, options):
"""Record a purchase in Sailthru
Arguments:
sailthru_client (object): SailthruClient
email (str): user's email address
item (dict): Sailthru required information about the course
purcha... | python | {
"resource": ""
} |
q273754 | _get_course_content | test | def _get_course_content(course_id, course_url, sailthru_client, site_code, config):
"""Get course information using the Sailthru content api or from cache.
If there is an error, just return with an empty response.
Arguments:
course_id (str): course key of the course
course_url (str): LMS u... | python | {
"resource": ""
} |
q273755 | _get_course_content_from_ecommerce | test | def _get_course_content_from_ecommerce(course_id, site_code=None):
"""
Get course information using the Ecommerce course api.
In case of error returns empty response.
Arguments:
course_id (str): course key of the course
site_code (str): site code
Returns:
course information... | python | {
"resource": ""
} |
q273756 | _update_unenrolled_list | test | def _update_unenrolled_list(sailthru_client, email, course_url, unenroll):
"""Maintain a list of courses the user has unenrolled from in the Sailthru user record
Arguments:
sailthru_client (object): SailthruClient
email (str): user's email address
course_url (str): LMS url for course in... | python | {
"resource": ""
} |
q273757 | send_course_refund_email | test | def send_course_refund_email(self, email, refund_id, amount, course_name, order_number, order_url, site_code=None):
""" Sends the course refund email.
Args:
self: Ignore.
email (str): Recipient's email address.
refund_id (int): ID of the refund that initiated this task.
amount (... | python | {
"resource": ""
} |
q273758 | _send_offer_assignment_notification_email | test | def _send_offer_assignment_notification_email(config, user_email, subject, email_body, site_code, task):
"""Handles sending offer assignment notification emails and retrying failed emails when appropriate."""
try:
sailthru_client = get_sailthru_client(site_code)
except SailthruError:
logger.... | python | {
"resource": ""
} |
q273759 | get_logger_config | test | def get_logger_config(log_dir='/var/tmp',
logging_env='no_env',
edx_filename='edx.log',
dev_env=False,
debug=False,
local_loglevel='INFO',
service_variant='ecomworker'):
"""
Retur... | python | {
"resource": ""
} |
q273760 | _retry_order | test | def _retry_order(self, exception, max_fulfillment_retries, order_number):
"""
Retry with exponential backoff until fulfillment
succeeds or the retry limit is reached. If the retry limit is exceeded,
the exception is re-raised.
"""
retries = self.request.retries
if retries == max_fulfillment_... | python | {
"resource": ""
} |
q273761 | fulfill_order | test | def fulfill_order(self, order_number, site_code=None, email_opt_in=False):
"""Fulfills an order.
Arguments:
order_number (str): Order number indicating which order to fulfill.
Returns:
None
"""
max_fulfillment_retries = get_configuration('MAX_FULFILLMENT_RETRIES', site_code=site_co... | python | {
"resource": ""
} |
q273762 | get_sailthru_client | test | def get_sailthru_client(site_code):
"""
Returns a Sailthru client for the specified site.
Args:
site_code (str): Site for which the client should be configured.
Returns:
SailthruClient
Raises:
SailthruNotEnabled: If Sailthru is not enabled for the specified site.
C... | python | {
"resource": ""
} |
q273763 | Cache.get | test | def get(self, key):
"""Get an object from the cache
Arguments:
key (str): Cache key
Returns:
Cached object
"""
lock.acquire()
try:
if key not in self:
return None
current_time = time.time()
if ... | python | {
"resource": ""
} |
q273764 | Cache.set | test | def set(self, key, value, duration):
"""Save an object in the cache
Arguments:
key (str): Cache key
value (object): object to cache
duration (int): time in seconds to keep object in cache
"""
lock.acquire()
try:
self[key] = CacheO... | python | {
"resource": ""
} |
q273765 | get_configuration | test | def get_configuration(variable, site_code=None):
"""
Get a value from configuration.
Retrieves the value corresponding to the given variable from the configuration module
currently in use by the app. Specify a site_code value to check for a site-specific override.
Arguments:
variable (str... | python | {
"resource": ""
} |
q273766 | get_overrides_filename | test | def get_overrides_filename(variable):
"""
Get the name of the file containing configuration overrides
from the provided environment variable.
"""
filename = os.environ.get(variable)
if filename is None:
msg = 'Please set the {} environment variable.'.format(variable)
raise Envir... | python | {
"resource": ""
} |
q273767 | get_value_by_version | test | def get_value_by_version(d):
"""
Finds the value depending in current eplus version.
Parameters
----------
d: dict
{(0, 0): value, (x, x): value, ...}
for current version (cv), current value is the value of version v such as v <= cv < v+1
"""
from oplus import CONF # touch... | python | {
"resource": ""
} |
q273768 | _Conf.eplus_version | test | def eplus_version(self):
"""
if _eplus_version is defined => _eplus_version
else most recent eplus available version
"""
# check energy plus is installed
if len(self.eplus_available_versions) == 0:
raise RuntimeError("Energy plus is not install, can't use oplu... | python | {
"resource": ""
} |
q273769 | Simulation._file_refs | test | def _file_refs(self):
"""
Defined here so that we can use the class variables, in order to subclass in oplusplus
"""
if self._prepared_file_refs is None:
self._prepared_file_refs = {
FILE_REFS.idf: FileInfo(
constructor=lambda path: self._e... | python | {
"resource": ""
} |
q273770 | Epm._dev_populate_from_json_data | test | def _dev_populate_from_json_data(self, json_data):
"""
!! Must only be called once, when empty !!
"""
# workflow
# --------
# (methods belonging to create/update/delete framework:
# epm._dev_populate_from_json_data, table.batch_add, record.update, queryset.de... | python | {
"resource": ""
} |
q273771 | Epm.get_external_files | test | def get_external_files(self):
"""
An external file manages file paths.
"""
external_files = []
for table in self._tables.values():
for r in table:
external_files.extend([ef for ef in r.get_external_files()])
return external_files | python | {
"resource": ""
} |
q273772 | Epm.set_defaults | test | def set_defaults(self):
"""
All fields of Epm with a default value and that are null will be set to their default value.
"""
for table in self._tables.values():
for r in table:
r.set_defaults() | python | {
"resource": ""
} |
q273773 | TableDescriptor.prepare_extensible | test | def prepare_extensible(self):
"""
This function finishes initialization, must be called once all field descriptors and tag have been filled.
"""
# see if extensible and store cycle len
for k in self._tags:
if "extensible" in k:
cycle_len = int(k.split(... | python | {
"resource": ""
} |
q273774 | TableDescriptor.get_extended_name | test | def get_extended_name(self, index):
"""
manages extensible names
"""
field_descriptor = self.get_field_descriptor(index)
if self.extensible_info is None:
return field_descriptor.name
cycle_start, cycle_len, _ = self.extensible_info
cycle_num = (index -... | python | {
"resource": ""
} |
q273775 | ExternalFilesManager.short_refs | test | def short_refs(self):
"""
we calculate on the fly to avoid managing registrations and un-registrations
Returns
-------
{ref: short_ref, ...
"""
naive_short_refs_d = dict() # naive_short_ref: {refs, ...}
for ef in self._external_files:
if ef.n... | python | {
"resource": ""
} |
q273776 | EioTable.get_value | test | def get_value(self, column_name_or_i, filter_column_name_or_i, filter_criterion):
"""
Returns first occurrence of value of filter column matching filter criterion.
"""
# find column indexes
column_i = self._get_column_index(column_name_or_i)
filter_column_i = self._get_co... | python | {
"resource": ""
} |
q273777 | Record._update_value_inert | test | def _update_value_inert(self, index, value):
"""
is only called by _update_inert
"""
# get field descriptor
field_descriptor = self._table._dev_descriptor.get_field_descriptor(index)
# prepare value
value = field_descriptor.deserialize(value, index)
# un... | python | {
"resource": ""
} |
q273778 | Record.update | test | def update(self, data=None, **or_data):
"""
Updates simultaneously all given fields.
Parameters
----------
data: dictionary containing field lowercase names or index as keys, and field values as values (dict syntax)
or_data: keyword arguments containing field names as ke... | python | {
"resource": ""
} |
q273779 | Record.set_defaults | test | def set_defaults(self):
"""
sets all empty fields for which a default value is defined to default value
"""
defaults = {}
for i in range(len(self)):
if i in self._data:
continue
default = self.get_field_descriptor(i).tags.get("default", [No... | python | {
"resource": ""
} |
q273780 | Record.add_fields | test | def add_fields(self, *args):
"""
This method only works for extensible fields. It allows to add values without precising their fields' names
or indexes.
Parameters
----------
args: field values
"""
if not self.is_extensible():
raise TypeError(... | python | {
"resource": ""
} |
q273781 | Record.pop | test | def pop(self, index=None):
"""
This method only works for extensible fields. It allows to remove a value and shift all other values to fill
the gap.
Parameters
----------
index: int, default None
index of field to remove.
Returns
-------
... | python | {
"resource": ""
} |
q273782 | Record.insert | test | def insert(self, index, value):
"""
This method only works for extensible fields. It allows to insert a value, and shifts all other following
values.
Parameters
----------
index: position of insertion
value: value to insert
"""
# prepare index (wi... | python | {
"resource": ""
} |
q273783 | Record.delete | test | def delete(self):
"""
Deletes record, and removes it from database.
"""
# workflow
# --------
# (methods belonging to create/update/delete framework:
# epm._dev_populate_from_json_data, table.batch_add, record.update, queryset.delete, record.delete)
# ... | python | {
"resource": ""
} |
q273784 | RelationsManager.register_record_hook | test | def register_record_hook(self, hook):
"""
target record must have been set
"""
for key in hook.keys:
if key in self._record_hooks:
field_descriptor = hook.target_record.get_field_descriptor(hook.target_index)
raise FieldValidationError(
... | python | {
"resource": ""
} |
q273785 | RelationsManager.register_link | test | def register_link(self, link):
"""
source record and index must have been set
"""
keys = tuple((ref, link.initial_hook_value) for ref in link.hook_references)
# look for a record hook
for k in keys:
if k in self._record_hooks:
# set link targe... | python | {
"resource": ""
} |
q273786 | IntentContainer._create_regex | test | def _create_regex(self, line, intent_name):
""" Create regex and return. If error occurs returns None. """
try:
return re.compile(self._create_intent_pattern(line, intent_name),
re.IGNORECASE)
except sre_constants.error as e:
LOG.warning('Fai... | python | {
"resource": ""
} |
q273787 | BaseEvent.remaining_duration | test | def remaining_duration(self, time):
'''Returns the remaining duration for a recording.
'''
return max(0, self.end - max(self.start, time)) | python | {
"resource": ""
} |
q273788 | BaseEvent.serialize | test | def serialize(self):
'''Serialize this object as dictionary usable for conversion to JSON.
:return: Dictionary representing this object.
'''
return {
'type': 'event',
'id': self.uid,
'attributes': {
'start': self.start,
... | python | {
"resource": ""
} |
q273789 | http_request | test | def http_request(url, post_data=None):
'''Make an HTTP request to a given URL with optional parameters.
'''
logger.debug('Requesting URL: %s' % url)
buf = bio()
curl = pycurl.Curl()
curl.setopt(curl.URL, url.encode('ascii', 'ignore'))
# Disable HTTPS verification methods if insecure is set
... | python | {
"resource": ""
} |
q273790 | get_service | test | def get_service(service_type):
'''Get available service endpoints for a given service type from the
Opencast ServiceRegistry.
'''
endpoint = '/services/available.json?serviceType=' + str(service_type)
url = '%s%s' % (config()['server']['url'], endpoint)
response = http_request(url).decode('utf-8... | python | {
"resource": ""
} |
q273791 | try_mkdir | test | def try_mkdir(directory):
'''Try to create a directory. Pass without error if it already exists.
'''
try:
os.mkdir(directory)
except OSError as err:
if err.errno != errno.EEXIST:
raise err | python | {
"resource": ""
} |
q273792 | configure_service | test | def configure_service(service):
'''Get the location of a given service from Opencast and add it to the
current configuration.
'''
while not config().get('service-' + service) and not terminate():
try:
config()['service-' + service] = \
get_service('org.opencastproject... | python | {
"resource": ""
} |
q273793 | register_ca | test | def register_ca(status='idle'):
'''Register this capture agent at the Matterhorn admin server so that it
shows up in the admin interface.
:param address: Address of the capture agent web ui
:param status: Current status of the capture agent
'''
# If this is a backup CA we don't tell the Matterh... | python | {
"resource": ""
} |
q273794 | recording_state | test | def recording_state(recording_id, status):
'''Send the state of the current recording to the Matterhorn core.
:param recording_id: ID of the current recording
:param status: Status of the recording
'''
# If this is a backup CA we do not update the recording state since the
# actual CA does that... | python | {
"resource": ""
} |
q273795 | update_event_status | test | def update_event_status(event, status):
'''Update the status of a particular event in the database.
'''
dbs = db.get_session()
dbs.query(db.RecordedEvent).filter(db.RecordedEvent.start == event.start)\
.update({'status': status})
event.status = status
dbs.commit() | python | {
"resource": ""
} |
q273796 | update_agent_state | test | def update_agent_state():
'''Update the current agent state in opencast.
'''
configure_service('capture.admin')
status = 'idle'
# Determine reported agent state with priority list
if get_service_status(db.Service.SCHEDULE) == db.ServiceStatus.STOPPED:
status = 'offline'
elif get_ser... | python | {
"resource": ""
} |
q273797 | configuration_file | test | def configuration_file(cfgfile):
'''Find the best match for the configuration file.
'''
if cfgfile is not None:
return cfgfile
# If no file is explicitely specified, probe for the configuration file
# location.
cfg = './etc/pyca.conf'
if not os.path.isfile(cfg):
return '/etc/... | python | {
"resource": ""
} |
q273798 | update_configuration | test | def update_configuration(cfgfile=None):
'''Update configuration from file.
:param cfgfile: Configuration file to load.
'''
configobj.DEFAULT_INTERPOLATION = 'template'
cfgfile = configuration_file(cfgfile)
cfg = configobj.ConfigObj(cfgfile, configspec=cfgspec, encoding='utf-8')
validator = ... | python | {
"resource": ""
} |
q273799 | check | test | def check():
'''Check configuration for sanity.
'''
if config('server')['insecure']:
logger.warning('HTTPS CHECKS ARE TURNED OFF. A SECURE CONNECTION IS '
'NOT GUARANTEED')
if config('server')['certificate']:
# Ensure certificate exists and is readable
open... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.