_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q17200 | publish | train | def publish(event_type: str,
event_data: dict = None,
object_type: str = None,
object_id: str = None,
object_key: str = None,
origin: str = None):
"""Publish an event.
Published the event to all subscribers and stores the event with the
object.
... | python | {
"resource": ""
} |
q17201 | _get_events_list | train | def _get_events_list(object_key: str) -> List[str]:
"""Get list of event ids for the object with the specified key.
Args:
object_key (str): Key of an object in the database.
"""
return DB.get_list(_keys.events_list(object_key)) | python | {
"resource": ""
} |
q17202 | _get_events_data | train | def _get_events_data(object_key: str) -> List[dict]:
"""Get the list of event data for the object with the specified key.
Args:
object_key (str): Key of an object in the database.
"""
events_data = []
key = _keys.events_data(object_key)
for event_id in _get_events_list(object_key):
... | python | {
"resource": ""
} |
q17203 | get_events | train | def get_events(object_key: str) -> List[Event]:
"""Get list of events for the object with the specified key."""
events_data = _get_events_data(object_key)
return [Event.from_config(event_dict) for event_dict in events_data] | python | {
"resource": ""
} |
q17204 | _publish_to_subscribers | train | def _publish_to_subscribers(event: Event):
"""Publish and event to all subscribers.
- Adds the event id to the published event list for all subscribers.
- Adds the event data to the published event data for all subscribers.
- Publishes the event id notification to all subscribers.
Args:
ev... | python | {
"resource": ""
} |
q17205 | _update_object | train | def _update_object(object_key: str, event: Event):
"""Update the events list and events data for the object.
- Adds the event Id to the list of events for the object.
- Adds the event data to the hash of object event data keyed by event
id.
Args:
object_key (str): Key of the object being... | python | {
"resource": ""
} |
q17206 | _get_event_id | train | def _get_event_id(object_type: str) -> str:
"""Return an event key for the event on the object type.
This must be a unique event id for the object.
Args:
object_type (str): Type of object
Returns:
str, event id
"""
key = _keys.event_counter(object_type)
DB.watch(key, pipe... | python | {
"resource": ""
} |
q17207 | ProcessingBlockDevice.pb_id | train | def pb_id(self, pb_id: str):
"""Set the PB Id for this device."""
# FIXME(BMo) instead of creating the object to check if the PB exists
# use a method on PB List?
# ProcessingBlock(pb_id)
self.set_state(DevState.ON)
self._pb_id = pb_id | python | {
"resource": ""
} |
q17208 | ProcessingBlockDevice.pb_config | train | def pb_config(self):
"""Return the PB configuration."""
pb = ProcessingBlock(self._pb_id)
return json.dumps(pb.config) | python | {
"resource": ""
} |
q17209 | StateObject.current_timestamp | train | def current_timestamp(self) -> datetime:
"""Get the current state timestamp."""
timestamp = DB.get_hash_value(self._key, 'current_timestamp')
return datetime_from_isoformat(timestamp) | python | {
"resource": ""
} |
q17210 | StateObject.target_timestamp | train | def target_timestamp(self) -> datetime:
"""Get the target state timestamp."""
timestamp = DB.get_hash_value(self._key, 'target_timestamp')
return datetime_from_isoformat(timestamp) | python | {
"resource": ""
} |
q17211 | StateObject.update_target_state | train | def update_target_state(self, value: str, force: bool = True) -> datetime:
"""Set the target state.
Args:
value (str): New value for target state
force (bool): If true, ignore allowed transitions
Returns:
datetime, update timestamp
Raises:
... | python | {
"resource": ""
} |
q17212 | StateObject.update_current_state | train | def update_current_state(self, value: str,
force: bool = False) -> datetime:
"""Update the current state.
Args:
value (str): New value for sdp state
force (bool): If true, ignore allowed transitions
Returns:
datetime, update time... | python | {
"resource": ""
} |
q17213 | StateObject._initialise | train | def _initialise(self, initial_state: str = 'unknown') -> dict:
"""Return a dictionary used to initialise a state object.
This method is used to obtain a dictionary/hash describing the initial
state of SDP or a service in SDP.
Args:
initial_state (str): Initial state.
... | python | {
"resource": ""
} |
q17214 | ConfigDb.add_sched_block_instance | train | def add_sched_block_instance(self, config_dict):
"""Add Scheduling Block to the database.
Args:
config_dict (dict): SBI configuration
"""
# Get schema for validation
schema = self._get_schema()
LOG.debug('Adding SBI with config: %s', config_dict)
# ... | python | {
"resource": ""
} |
q17215 | ConfigDb.get_sched_block_instance_ids | train | def get_sched_block_instance_ids(self):
"""Get unordered list of scheduling block ids"""
# Initialise empty list
scheduling_block_ids = []
# Pattern used to search scheduling block ids
pattern = 'scheduling_block:*'
block_ids = self._db.get_ids(pattern)
for blo... | python | {
"resource": ""
} |
q17216 | ConfigDb.get_processing_block_ids | train | def get_processing_block_ids(self):
"""Get list of processing block ids using the processing block id"""
# Initialise empty list
_processing_block_ids = []
# Pattern used to search processing block ids
pattern = '*:processing_block:*'
block_ids = self._db.get_ids(patter... | python | {
"resource": ""
} |
q17217 | ConfigDb.get_sub_array_ids | train | def get_sub_array_ids(self):
"""Get list of sub array ids"""
# Initialise empty list
_scheduling_block_ids = []
_sub_array_ids = []
for blocks_id in self.get_sched_block_instance_ids():
_scheduling_block_ids.append(blocks_id)
block_details = self.get_block_d... | python | {
"resource": ""
} |
q17218 | ConfigDb.get_sub_array_sbi_ids | train | def get_sub_array_sbi_ids(self, sub_array_id):
"""Get Scheduling Block Instance ID associated with sub array id"""
_ids = []
sbi_ids = self.get_sched_block_instance_ids()
for details in self.get_block_details(sbi_ids):
if details['sub_array_id'] == sub_array_id:
... | python | {
"resource": ""
} |
q17219 | ConfigDb.get_block_details | train | def get_block_details(self, block_ids):
"""Get details of scheduling or processing block
Args:
block_ids (list): List of block IDs
"""
# Convert input to list if needed
if not hasattr(block_ids, "__iter__"):
block_ids = [block_ids]
for _id in blo... | python | {
"resource": ""
} |
q17220 | ConfigDb.update_value | train | def update_value(self, block_id, field, value):
""""Update the value of the given block id and field"""
block_name = self._db.get_block(block_id)
for name in block_name:
self._db.set_value(name, field, value) | python | {
"resource": ""
} |
q17221 | ConfigDb.delete_sched_block_instance | train | def delete_sched_block_instance(self, block_id):
"""Delete the specified Scheduling Block Instance.
Removes the Scheduling Block Instance, and all Processing Blocks
that belong to it from the database"""
LOG.debug('Deleting SBI %s', block_id)
scheduling_blocks = self._db.get_al... | python | {
"resource": ""
} |
q17222 | ConfigDb._get_schema | train | def _get_schema():
"""Get the schema for validation"""
schema_path = os.path.join(os.path.dirname(__file__),
'schema', 'scheduling_block_schema.json')
with open(schema_path, 'r') as file:
schema_data = file.read()
schema = json.loads(schema_... | python | {
"resource": ""
} |
q17223 | ConfigDb._add_status | train | def _add_status(scheduling_block):
"""This function adds status fields to all the section
in the scheduling block instance"""
scheduling_block['status'] = "created"
for block in scheduling_block:
if isinstance(scheduling_block[block], list):
for field in sched... | python | {
"resource": ""
} |
q17224 | ConfigDb._split_sched_block_instance | train | def _split_sched_block_instance(self, scheduling_block):
"""Split the scheduling block data into multiple names
before adding to the configuration database"""
# Initialise empty list
_scheduling_block_data = {}
_processing_block_data = {}
_processing_block_id = []
... | python | {
"resource": ""
} |
q17225 | init_logger | train | def init_logger(logger_name='sip', log_level=None, p3_mode: bool = True,
show_thread: bool = False, propagate: bool = False,
show_log_origin=False):
"""Initialise the SIP logger.
Attaches a stdout stream handler to the 'sip' logger. This will
apply to all logger objects with... | python | {
"resource": ""
} |
q17226 | disable_logger | train | def disable_logger(logger_name: str, propagate: bool = False):
"""Disable output for the logger of the specified name."""
log = logging.getLogger(logger_name)
log.propagate = propagate
for handler in log.handlers:
log.removeHandler(handler) | python | {
"resource": ""
} |
q17227 | set_log_level | train | def set_log_level(logger_name: str, log_level: str, propagate: bool = False):
"""Set the log level of the specified logger."""
log = logging.getLogger(logger_name)
log.propagate = propagate
log.setLevel(log_level) | python | {
"resource": ""
} |
q17228 | SIPFormatter.formatTime | train | def formatTime(self, record, datefmt=None):
"""Format the log timestamp."""
_seconds_fraction = record.created - int(record.created)
_datetime_utc = time.mktime(time.gmtime(record.created))
_datetime_utc += _seconds_fraction
_created = self.converter(_datetime_utc)
if da... | python | {
"resource": ""
} |
q17229 | generate_sbi | train | def generate_sbi(index: int = None):
"""Generate a SBI config JSON string."""
date = datetime.datetime.utcnow().strftime('%Y%m%d')
if index is None:
index = randint(0, 999)
sbi_id = 'SBI-{}-sip-demo-{:03d}'.format(date, index)
sb_id = 'SBI-{}-sip-demo-{:03d}'.format(date, index)
pb_id = ... | python | {
"resource": ""
} |
q17230 | PulsarSender.send | train | def send(self, config, log, obs_id, beam_id):
"""
Send the pulsar data to the ftp server
Args:
config (dict): Dictionary of settings
log (logging.Logger): Python logging object
obs_id: observation id
beam_id: beam id
"""
log.info('... | python | {
"resource": ""
} |
q17231 | SubarrayDevice.init_device | train | def init_device(self):
"""Initialise the device."""
Device.init_device(self)
time.sleep(0.1)
self.set_state(DevState.STANDBY) | python | {
"resource": ""
} |
q17232 | SubarrayDevice.configure | train | def configure(self, sbi_config: str):
"""Configure an SBI for this subarray.
Args:
sbi_config (str): SBI configuration JSON
Returns:
str,
"""
# print(sbi_config)
config_dict = json.loads(sbi_config)
self.debug_stream('SBI configuration:\... | python | {
"resource": ""
} |
q17233 | SubarrayDevice.processing_blocks | train | def processing_blocks(self):
"""Return list of PBs associated with the subarray.
<http://www.esrf.eu/computing/cs/tango/pytango/v920/server_api/server.html#PyTango.server.pipe>
"""
sbi_ids = Subarray(self.get_name()).sbi_ids
pbs = []
for sbi_id in sbi_ids:
sb... | python | {
"resource": ""
} |
q17234 | datetime_from_isoformat | train | def datetime_from_isoformat(value: str):
"""Return a datetime object from an isoformat string.
Args:
value (str): Datetime string in isoformat.
"""
if sys.version_info >= (3, 7):
return datetime.fromisoformat(value)
return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f') | python | {
"resource": ""
} |
q17235 | SDPMasterDevice.always_executed_hook | train | def always_executed_hook(self):
"""Run for each command."""
_logT = self._devProxy.get_logging_target()
if 'device::sip_sdp_logger' not in _logT:
try:
self._devProxy.add_logging_target('device::sip_sdp/elt/logger')
self.info_stream("Test of Tango loggi... | python | {
"resource": ""
} |
q17236 | SDPMasterDevice.configure | train | def configure(self, value):
"""Schedule an offline only SBI with SDP."""
# Only accept new SBIs if the SDP is on.
if self._sdp_state.current_state != 'on':
raise RuntimeWarning('Unable to configure SBIs unless SDP is '
'\'on\'.')
# Check tha... | python | {
"resource": ""
} |
q17237 | SDPMasterDevice._get_service_state | train | def _get_service_state(service_id: str):
"""Get the Service state object for the specified id."""
LOG.debug('Getting state of service %s', service_id)
services = get_service_id_list()
service_ids = [s for s in services if service_id in s]
if len(service_ids) != 1:
ret... | python | {
"resource": ""
} |
q17238 | SDPMasterDevice.allowed_target_sdp_states | train | def allowed_target_sdp_states(self):
"""Return a list of allowed target states for the current state."""
_current_state = self._sdp_state.current_state
_allowed_target_states = self._sdp_state.allowed_target_states[
_current_state]
return json.dumps(dict(allowed_target_sdp_st... | python | {
"resource": ""
} |
q17239 | SDPMasterDevice.target_sdp_state | train | def target_sdp_state(self, state):
"""Update the target state of SDP."""
LOG.info('Setting SDP target state to %s', state)
if self._sdp_state.current_state == state:
LOG.info('Target state ignored, SDP is already "%s"!', state)
if state == 'on':
self.set_state(Dev... | python | {
"resource": ""
} |
q17240 | SDPMasterDevice.health | train | def health(self):
"""Health check method, returns the up-time of the device."""
return json.dumps(dict(uptime='{:.3f}s'
.format((time.time() - self._start_time)))) | python | {
"resource": ""
} |
q17241 | SDPMasterDevice.scheduling_block_instances | train | def scheduling_block_instances(self):
"""Return the a JSON dict encoding the SBIs known to SDP."""
# TODO(BMo) change this to a pipe?
sbi_list = SchedulingBlockInstanceList()
return json.dumps(dict(active=sbi_list.active,
completed=sbi_list.completed,
... | python | {
"resource": ""
} |
q17242 | SDPMasterDevice.processing_blocks | train | def processing_blocks(self):
"""Return the a JSON dict encoding the PBs known to SDP."""
pb_list = ProcessingBlockList()
# TODO(BMo) realtime, offline etc.
return json.dumps(dict(active=pb_list.active,
completed=pb_list.completed,
... | python | {
"resource": ""
} |
q17243 | SDPMasterDevice.processing_block_devices | train | def processing_block_devices(self):
"""Get list of processing block devices."""
# Get the list and number of Tango PB devices
tango_db = Database()
pb_device_class = "ProcessingBlockDevice"
pb_device_server_instance = "processing_block_ds/1"
pb_devices = tango_db.get_devi... | python | {
"resource": ""
} |
q17244 | SDPMasterDevice._set_master_state | train | def _set_master_state(self, state):
"""Set the state of the SDPMaster."""
if state == 'init':
self._service_state.update_current_state('init', force=True)
self.set_state(DevState.INIT)
elif state == 'on':
self.set_state(DevState.ON)
self._service_... | python | {
"resource": ""
} |
q17245 | register_subarray_devices | train | def register_subarray_devices():
"""Register subarray devices."""
tango_db = Database()
LOG.info("Registering Subarray devices:")
device_info = DbDevInfo()
# pylint: disable=protected-access
device_info._class = "SubarrayDevice"
device_info.server = "subarray_ds/1"
for index in range(16... | python | {
"resource": ""
} |
q17246 | add_workflow_definitions | train | def add_workflow_definitions(sbi_config: dict):
"""Add any missing SBI workflow definitions as placeholders.
This is a utility function used in testing and adds mock / test workflow
definitions to the database for workflows defined in the specified
SBI config.
Args:
sbi_config (dict): SBI ... | python | {
"resource": ""
} |
q17247 | generate_version | train | def generate_version(max_major: int = 1, max_minor: int = 7,
max_patch: int = 15) -> str:
"""Select a random version.
Args:
max_major (int, optional) maximum major version
max_minor (int, optional) maximum minor version
max_patch (int, optional) maximum patch versio... | python | {
"resource": ""
} |
q17248 | generate_sb | train | def generate_sb(date: datetime.datetime, project: str,
programme_block: str) -> dict:
"""Generate a Scheduling Block data object.
Args:
date (datetime.datetime): UTC date of the SBI
project (str): Project Name
programme_block (str): Programme
Returns:
str, S... | python | {
"resource": ""
} |
q17249 | generate_pb_config | train | def generate_pb_config(pb_id: str,
pb_config: dict = None,
workflow_config: dict = None) -> dict:
"""Generate a PB configuration dictionary.
Args:
pb_id (str): Processing Block Id
pb_config (dict, optional) PB configuration.
workflow_config ... | python | {
"resource": ""
} |
q17250 | generate_sbi_config | train | def generate_sbi_config(num_pbs: int = 3, project: str = 'sip',
programme_block: str = 'sip_demos',
pb_config: Union[dict, List[dict]] = None,
workflow_config:
Union[dict, List[dict]] = None,
register... | python | {
"resource": ""
} |
q17251 | generate_sbi_json | train | def generate_sbi_json(num_pbs: int = 3, project: str = 'sip',
programme_block: str = 'sip_demos',
pb_config: Union[dict, List[dict]] = None,
workflow_config:
Union[dict, List[dict]] = None,
register_workflows=T... | python | {
"resource": ""
} |
q17252 | SDPLoggerDevice.log | train | def log(self, argin):
"""Log a command for the SDP STango ubsystem devices."""
#
# Tango Manual Appendix 9 gives the format
# argin[0] = millisecond Unix timestamp
# argin[1] = log level
# argin[2] = the source log device name
# argin[3] = the log message
... | python | {
"resource": ""
} |
q17253 | _scheduling_block_ids | train | def _scheduling_block_ids(num_blocks, start_id, project):
"""Generate Scheduling Block instance ID"""
for i in range(num_blocks):
_root = '{}-{}'.format(strftime("%Y%m%d", gmtime()), project)
yield '{}-sb{:03d}'.format(_root, i + start_id), \
'{}-sbi{:03d}'.format(_root, i + start_... | python | {
"resource": ""
} |
q17254 | _generate_processing_blocks | train | def _generate_processing_blocks(start_id, min_blocks=0, max_blocks=4):
"""Generate a number of Processing Blocks"""
processing_blocks = []
num_blocks = random.randint(min_blocks, max_blocks)
for i in range(start_id, start_id + num_blocks):
_id = 'sip-pb{:03d}'.format(i)
block = dict(id=_... | python | {
"resource": ""
} |
q17255 | _scheduling_block_config | train | def _scheduling_block_config(num_blocks=5, start_sbi_id=0, start_pb_id=0,
project='sip'):
"""Return a Scheduling Block Configuration dictionary"""
pb_id = start_pb_id
for sb_id, sbi_id in _scheduling_block_ids(num_blocks, start_sbi_id,
... | python | {
"resource": ""
} |
q17256 | add_scheduling_blocks | train | def add_scheduling_blocks(num_blocks, clear=True):
"""Add a number of scheduling blocks to the db."""
db_client = ConfigDb()
if clear:
LOG.info('Resetting database ...')
db_client.clear()
start_sbi_id = 0
start_pb_id = 0
else:
start_sbi_id = len(db_client.get_sche... | python | {
"resource": ""
} |
q17257 | main | train | def main(args=None, **kwargs):
"""Start the Processing Block device server."""
LOG.info('Starting SDP PB devices.')
return run([ProcessingBlockDevice], verbose=True, msg_stream=sys.stdout,
args=args, **kwargs) | python | {
"resource": ""
} |
q17258 | ProcessingBlock.dependencies | train | def dependencies(self) -> List[Dependency]:
"""Return the PB dependencies."""
dependencies_str = DB.get_hash_value(self.key, 'dependencies')
dependencies = []
for dependency in ast.literal_eval(dependencies_str):
dependencies.append(Dependency(dependency))
return depe... | python | {
"resource": ""
} |
q17259 | ProcessingBlock.resources_assigned | train | def resources_assigned(self) -> List[Resource]:
"""Return list of resources assigned to the PB."""
resources_str = DB.get_hash_value(self.key, 'resources_assigned')
resources_assigned = []
for resource in ast.literal_eval(resources_str):
resources_assigned.append(Resource(res... | python | {
"resource": ""
} |
q17260 | ProcessingBlock.workflow_stages | train | def workflow_stages(self) -> List[WorkflowStage]:
"""Return list of workflow stages.
Returns:
dict, resources of a specified pb
"""
workflow_stages = []
stages = DB.get_hash_value(self.key, 'workflow_stages')
for index in range(len(ast.literal_eval(stages)))... | python | {
"resource": ""
} |
q17261 | ProcessingBlock.add_assigned_resource | train | def add_assigned_resource(self, resource_type: str,
value: Union[str, int, float, bool],
parameters: dict = None):
"""Add assigned resource to the processing block.
Args:
resource_type (str): Resource type
value: Resour... | python | {
"resource": ""
} |
q17262 | ProcessingBlock.remove_assigned_resource | train | def remove_assigned_resource(self, resource_type: str,
value: Union[str, int, float, bool] = None,
parameters: dict = None):
"""Remove assigned resources from the processing block.
All matching resources will be removed. If only type is ... | python | {
"resource": ""
} |
q17263 | ProcessingBlock.abort | train | def abort(self):
"""Abort the processing_block."""
LOG.debug('Aborting PB %s', self._id)
self.set_status('aborted')
pb_type = DB.get_hash_value(self.key, 'type')
key = '{}:active'.format(self._type)
DB.remove_from_list(key, self._id)
key = '{}:active:{}'.format(se... | python | {
"resource": ""
} |
q17264 | ProcessingBlock._mark_updated | train | def _mark_updated(self):
"""Update the updated timestamp."""
timestamp = datetime.datetime.utcnow().isoformat()
DB.set_hash_value(self.key, 'updated', timestamp) | python | {
"resource": ""
} |
q17265 | get | train | def get():
"""Subarray list.
This method will list all sub-arrays known to SDP.
"""
_url = get_root_url()
LOG.debug('GET Sub array list')
sub_array_ids = sorted(DB.get_sub_array_ids())
response = dict(sub_arrays=[])
for array_id in sub_array_ids:
array_summary = dict(sub_arrar... | python | {
"resource": ""
} |
q17266 | post | train | def post():
"""Generate a SBI."""
_url = get_root_url()
LOG.debug("POST subarray SBI.")
# TODO(BM) generate sbi_config .. see report ...
# ... will need to add this as a util function on the db...
sbi_config = {}
DB.add_sbi(sbi_config)
response = dict()
return response, status.HTT... | python | {
"resource": ""
} |
q17267 | Subarray.set_parameters | train | def set_parameters(self, parameters_dict):
"""Set the subarray parameters.
Args:
parameters_dict (dict): Dictionary of Subarray parameters
"""
DB.set_hash_value(self._key, 'parameters', parameters_dict)
self.publish("parameters_updated") | python | {
"resource": ""
} |
q17268 | Subarray.sbi_ids | train | def sbi_ids(self) -> List[str]:
"""Get the list of SBI Ids.
Returns:
list, list of SBI ids associated with this subarray.
"""
return ast.literal_eval(DB.get_hash_value(self._key, 'sbi_ids')) | python | {
"resource": ""
} |
q17269 | Subarray.configure_sbi | train | def configure_sbi(self, sbi_config: dict, schema_path: str = None):
"""Add a new SBI to the database associated with this subarray.
Args:
sbi_config (dict): SBI configuration.
schema_path (str, optional): Path to the SBI config schema.
"""
if not self.active:
... | python | {
"resource": ""
} |
q17270 | Subarray.abort | train | def abort(self):
"""Abort all SBIs associated with the subarray."""
for sbi_id in self.sbi_ids:
sbi = SchedulingBlockInstance(sbi_id)
sbi.abort()
self.set_state('ABORTED') | python | {
"resource": ""
} |
q17271 | Subarray.deactivate | train | def deactivate(self):
"""Deactivate the subarray."""
DB.set_hash_value(self._key, 'active', 'False')
# Remove the subarray from each of the SBIs
for sbi_id in self.sbi_ids:
SchedulingBlockInstance(sbi_id).clear_subarray()
DB.set_hash_value(self._key, 'sbi_ids', [])
... | python | {
"resource": ""
} |
q17272 | Subarray.remove_sbi_id | train | def remove_sbi_id(self, sbi_id):
"""Remove an SBI Identifier."""
sbi_ids = self.sbi_ids
sbi_ids.remove(sbi_id)
DB.set_hash_value(self._key, 'sbi_ids', sbi_ids) | python | {
"resource": ""
} |
q17273 | Subarray._add_sbi_id | train | def _add_sbi_id(self, sbi_id):
"""Add a SBI Identifier."""
sbi_ids = self.sbi_ids
sbi_ids.append(sbi_id)
DB.set_hash_value(self._key, 'sbi_ids', sbi_ids) | python | {
"resource": ""
} |
q17274 | EventQueue.get | train | def get(self) -> Union[Event, None]:
"""Get the latest event from the queue.
Call this method to query the queue for the latest event.
If no event has been published None is returned.
Returns:
Event or None
"""
message = self._queue.get_message()
... | python | {
"resource": ""
} |
q17275 | EventQueue.get_processed_events | train | def get_processed_events(self) -> List[Event]:
"""Get all processed events.
This method is intended to be used to recover events stuck in the
processed state which could happen if an event handling processing
an processed event goes down before completing the event processing.
... | python | {
"resource": ""
} |
q17276 | EventQueue.complete_event | train | def complete_event(self, event_id: str):
"""Complete the specified event."""
event_ids = DB.get_list(self._processed_key)
if event_id not in event_ids:
raise KeyError('Unable to complete event. Event {} has not been '
'processed (ie. it is not in the proces... | python | {
"resource": ""
} |
q17277 | add | train | def add(workflow_definition: dict, templates_root: str):
"""Add a workflow definition to the Configuration Database.
Templates are expected to be found in a directory tree with the following
structure:
- workflow_id:
|- workflow_version
|- stage_id
|... | python | {
"resource": ""
} |
q17278 | delete | train | def delete(workflow_id: str = None, workflow_version: str = None):
"""Delete workflow definitions.
Args:
workflow_id (str, optional): Optional workflow identifier
workflow_version (str, optional): Optional workflow identifier version
If workflow_id and workflow_version are None, delete all... | python | {
"resource": ""
} |
q17279 | get_workflow | train | def get_workflow(workflow_id: str, workflow_version: str) -> dict:
"""Get a workflow definition from the Configuration Database.
Args:
workflow_id (str): Workflow identifier
workflow_version (str): Workflow version
Returns:
dict, Workflow definition dictionary
"""
name = "... | python | {
"resource": ""
} |
q17280 | get_workflows | train | def get_workflows() -> dict:
"""Get dict of ALL known workflow definitions.
Returns
list[dict]
"""
keys = DB.get_keys("workflow_definitions:*")
known_workflows = dict()
for key in keys:
values = key.split(':')
if values[1] not in known_workflows:
known_workf... | python | {
"resource": ""
} |
q17281 | _load_templates | train | def _load_templates(workflow: dict, templates_root: str):
"""Load templates keys."""
workflow_template_path = join(templates_root, workflow['id'],
workflow['version'])
for i, stage_config in enumerate(workflow['stages']):
stage_template_path = join(workflow_template... | python | {
"resource": ""
} |
q17282 | delete_pb_devices | train | def delete_pb_devices():
"""Delete PBs devices from the Tango database."""
parser = argparse.ArgumentParser(description='Register PB devices.')
parser.add_argument('num_pb', type=int,
help='Number of PBs devices to register.')
args = parser.parse_args()
log = logging.getLogg... | python | {
"resource": ""
} |
q17283 | main | train | def main():
"""Main function for SPEAD sender module."""
# Check command line arguments.
if len(sys.argv) != 2:
raise RuntimeError('Usage: python3 async_send.py <json config>')
# Set up logging.
sip_logging.init_logger(show_thread=False)
# Load SPEAD configuration from JSON file.
#... | python | {
"resource": ""
} |
q17284 | SpeadSender.fill_buffer | train | def fill_buffer(heap_data, i_chan):
"""Blocking function to populate data in the heap.
This is run in an executor.
"""
# Calculate the time count and fraction.
now = datetime.datetime.utcnow()
time_full = now.timestamp()
time_count = int(time_full)
time_fr... | python | {
"resource": ""
} |
q17285 | SpeadSender.run | train | def run(self):
"""Starts the sender."""
# Create the thread pool.
executor = concurrent.futures.ThreadPoolExecutor(
max_workers=self._config['num_workers'])
# Wait to ensure multiple senders can be synchronised.
now = int(datetime.datetime.utcnow().timestamp())
... | python | {
"resource": ""
} |
q17286 | SchedulingObjectList.set_complete | train | def set_complete(self, object_id: str):
"""Mark the specified object as completed."""
if object_id in self.active:
DB.remove_from_list('{}:active'.format(self.type), object_id)
DB.append_to_list('{}:completed'.format(self.type), object_id) | python | {
"resource": ""
} |
q17287 | SchedulingObjectList.publish | train | def publish(self, object_id: str, event_type: str,
event_data: dict = None):
"""Publish a scheduling object event.
Args:
object_id (str): ID of the scheduling object
event_type (str): Type of event.
event_data (dict, optional): Event data.
""... | python | {
"resource": ""
} |
q17288 | _start_workflow_stages | train | def _start_workflow_stages(pb: ProcessingBlock, pb_id: str,
workflow_stage_dict: dict,
workflow_stage: WorkflowStage,
docker: DockerSwarmClient):
"""Start a workflow stage by starting a number of docker services.
This function fir... | python | {
"resource": ""
} |
q17289 | _update_workflow_stages | train | def _update_workflow_stages(stage_data: dict, workflow_stage: WorkflowStage,
docker: DockerSwarmClient):
"""Check and update the status of a workflow stage.
This function checks and updates the status of a workflow stage
specified by the parameters in the specified stage_data di... | python | {
"resource": ""
} |
q17290 | _abort_workflow | train | def _abort_workflow(pb: ProcessingBlock, workflow_stage_dict: dict,
docker: DockerSwarmClient):
"""Abort the workflow.
TODO(BMo): This function currently does nothing as the abort flag
is hardcoded to False!
This function is used by `execute_processing_block`.
Args:
... | python | {
"resource": ""
} |
q17291 | _workflow_complete | train | def _workflow_complete(workflow_stage_dict: dict):
"""Check if the workflow is complete.
This function checks if the entire workflow is complete.
This function is used by `execute_processing_block`.
Args:
workflow_stage_dict (dict): Workflow metadata dictionary.
Returns:
bool, Tr... | python | {
"resource": ""
} |
q17292 | execute_processing_block | train | def execute_processing_block(pb_id: str, log_level='DEBUG'):
"""Execute a processing block.
Celery tasks that executes a workflow defined in a Configuration database
Processing Block data object.
Args:
pb_id (str): The PB id for the PBC
log_level (str): Python logging level.
"""
... | python | {
"resource": ""
} |
q17293 | ProcessingBlockQueue.put | train | def put(self, block_id, priority, pb_type='offline'):
"""Add a Processing Block to the queue.
When a new entry it added, the queue is (re-)sorted by priority
followed by insertion order (older blocks with equal priority are
first).
Args:
block_id (str): Processing B... | python | {
"resource": ""
} |
q17294 | ProcessingBlockQueue.get | train | def get(self):
"""Get the highest priority Processing Block from the queue."""
with self._mutex:
entry = self._queue.pop()
del self._block_map[entry[2]]
return entry[2] | python | {
"resource": ""
} |
q17295 | ProcessingBlockQueue.remove | train | def remove(self, block_id):
"""Remove a Processing Block from the queue.
Args:
block_id (str):
"""
with self._mutex:
entry = self._block_map[block_id]
self._queue.remove(entry) | python | {
"resource": ""
} |
q17296 | get_service_state_list | train | def get_service_state_list() -> List[ServiceState]:
"""Return a list of ServiceState objects known to SDP."""
keys = DB.get_keys('states*')
LOG.debug('Loading list of known services.')
services = []
for key in keys:
values = key.split(':')
if len(values) == 4:
services.ap... | python | {
"resource": ""
} |
q17297 | get_service_id_list | train | def get_service_id_list() -> List[tuple]:
"""Return list of Services."""
keys = DB.get_keys('states*')
services = []
for key in keys:
values = key.split(':')
if len(values) == 4:
services.append(':'.join(values[1:]))
return services | python | {
"resource": ""
} |
q17298 | get | train | def get():
"""Return the list of Processing Blocks known to SDP."""
LOG.debug('GET Processing Block list')
_url = get_root_url()
# Get list of Processing block Ids
block_ids = sorted(DB.get_processing_block_ids())
LOG.debug('Processing Block IDs: %s', block_ids)
# Construct response objec... | python | {
"resource": ""
} |
q17299 | SchedulingObject.config | train | def config(self) -> dict:
"""Get the scheduling object config."""
# Check that the key exists
self._check_object_exists()
config_dict = DB.get_hash_dict(self.key)
for _, value in config_dict.items():
for char in ['[', '{']:
if char in value:
... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.