_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q16900 | Context.block_view | train | def block_view(self, mri):
# type: (str) -> Block
"""Get a view of a block
Args:
mri: The mri of the controller hosting the block
Returns:
Block: The block we control
"""
controller = self.get_controller(mri)
block = controller.block_view... | python | {
"resource": ""
} |
q16901 | Context.set_notify_dispatch_request | train | def set_notify_dispatch_request(self, notify_dispatch_request, *args):
"""Set function to call just before requests are dispatched
Args:
notify_dispatch_request (callable): function will be called
with request as single arg just before request is dispatched
"""
... | python | {
"resource": ""
} |
q16902 | Context.ignore_stops_before_now | train | def ignore_stops_before_now(self):
"""Ignore any stops received before this point"""
self._sentinel_stop = object()
self._q.put(self._sentinel_stop) | python | {
"resource": ""
} |
q16903 | Context.put | train | def put(self, path, value, timeout=None, event_timeout=None):
""""Puts a value to a path and returns when it completes
Args:
path (list): The path to put to
value (object): The value to set
timeout (float): time in seconds to wait for responses, wait forever
... | python | {
"resource": ""
} |
q16904 | Context.put_async | train | def put_async(self, path, value):
""""Puts a value to a path and returns immediately
Args:
path (list): The path to put to
value (object): The value to set
Returns:
Future: A single Future which will resolve to the result
"""
request = Put(s... | python | {
"resource": ""
} |
q16905 | Context.post | train | def post(self, path, params=None, timeout=None, event_timeout=None):
"""Synchronously calls a method
Args:
path (list): The path to post to
params (dict): parameters for the call
timeout (float): time in seconds to wait for responses, wait
forever if ... | python | {
"resource": ""
} |
q16906 | Context.post_async | train | def post_async(self, path, params=None):
"""Asynchronously calls a function on a child block
Args:
path (list): The path to post to
params (dict): parameters for the call
Returns:
Future: as single Future that will resolve to the result
"""
... | python | {
"resource": ""
} |
q16907 | Context.unsubscribe | train | def unsubscribe(self, future):
"""Terminates the subscription given by a future
Args:
future (Future): The future of the original subscription
"""
assert future not in self._pending_unsubscribes, \
"%r has already been unsubscribed from" % \
self._pen... | python | {
"resource": ""
} |
q16908 | Context.unsubscribe_all | train | def unsubscribe_all(self, callback=False):
"""Send an unsubscribe for all active subscriptions"""
futures = ((f, r) for f, r in self._requests.items()
if isinstance(r, Subscribe)
and f not in self._pending_unsubscribes)
if futures:
for future, re... | python | {
"resource": ""
} |
q16909 | Context.when_matches | train | def when_matches(self, path, good_value, bad_values=None, timeout=None,
event_timeout=None):
"""Resolve when an path value equals value
Args:
path (list): The path to wait to
good_value (object): the value to wait for
bad_values (list): values to... | python | {
"resource": ""
} |
q16910 | Context.when_matches_async | train | def when_matches_async(self, path, good_value, bad_values=None):
"""Wait for an attribute to become a given value
Args:
path (list): The path to wait to
good_value: If it is a callable then expect it to return
True if we are satisfied and raise on error. If it is... | python | {
"resource": ""
} |
q16911 | Context.wait_all_futures | train | def wait_all_futures(self, futures, timeout=None, event_timeout=None):
# type: (Union[List[Future], Future, None], float, float) -> None
"""Services all futures until the list 'futures' are all done
then returns. Calls relevant subscription callbacks as they
come off the queue and raises... | python | {
"resource": ""
} |
q16912 | Context.sleep | train | def sleep(self, seconds):
"""Services all futures while waiting
Args:
seconds (float): Time to wait
"""
until = time.time() + seconds
try:
while True:
self._service_futures([], until)
except TimeoutError:
return | python | {
"resource": ""
} |
q16913 | Spawned.get | train | def get(self, timeout=None):
# type: (float) -> T
"""Return the result or raise the error the function has produced"""
self.wait(timeout)
if isinstance(self._result, Exception):
raise self._result
return self._result | python | {
"resource": ""
} |
q16914 | RunnableController.update_configure_params | train | def update_configure_params(self, part=None, info=None):
# type: (Part, ConfigureParamsInfo) -> None
"""Tell controller part needs different things passed to Configure"""
with self.changes_squashed:
# Update the dict
if part:
self.part_configure_params[par... | python | {
"resource": ""
} |
q16915 | RunnableController.validate | train | def validate(self, generator, axesToMove=None, **kwargs):
# type: (AGenerator, AAxesToMove, **Any) -> AConfigureParams
"""Validate configuration parameters and return validated parameters.
Doesn't take device state into account so can be run in any state
"""
iterations = 10
... | python | {
"resource": ""
} |
q16916 | RunnableController.abort | train | def abort(self):
# type: () -> None
"""Abort the current operation and block until aborted
Normally it will return in Aborted state. If something goes wrong it
will return in Fault state. If the user disables then it will return in
Disabled state.
"""
# Tell _cal... | python | {
"resource": ""
} |
q16917 | RunnableController.resume | train | def resume(self):
# type: () -> None
"""Resume a paused scan.
Normally it will return in Running state. If something goes wrong it
will return in Fault state.
"""
self.transition(ss.RUNNING)
self.resume_queue.put(True) | python | {
"resource": ""
} |
q16918 | ConfigureHook.create_info | train | def create_info(cls, configure_func):
# type: (Callable) -> ConfigureParamsInfo
"""Create a `ConfigureParamsInfo` describing the extra parameters
that should be passed at configure"""
call_types = getattr(configure_func, "call_types",
{}) # type: Dict[str, A... | python | {
"resource": ""
} |
q16919 | Hookable.register_hooked | train | def register_hooked(self,
hooks, # type: Union[Type[Hook], Sequence[Type[Hook]]]
func, # type: Hooked
args_gen=None # type: Optional[ArgsGen]
):
# type: (Type[Hook], Callable, Optional[Callable]) -> None
"... | python | {
"resource": ""
} |
q16920 | Hookable.on_hook | train | def on_hook(self, hook):
# type: (Hook) -> None
"""Takes a hook, and optionally calls hook.run on a function"""
try:
func, args_gen = self.hooked[type(hook)]
except (KeyError, TypeError):
return
else:
hook(func, args_gen()) | python | {
"resource": ""
} |
q16921 | StateSet.transition_allowed | train | def transition_allowed(self, initial_state, target_state):
# type: (str, str) -> bool
"""Check if a transition between two states is allowed"""
assert initial_state in self._allowed, \
"%s is not in %s" % (initial_state, list(self._allowed))
return target_state in self._allow... | python | {
"resource": ""
} |
q16922 | StateSet.set_allowed | train | def set_allowed(self, initial_state, *allowed_states):
# type: (str, *str) -> None
"""Add an allowed transition from initial_state to allowed_states"""
allowed_states = list(allowed_states)
self._allowed.setdefault(initial_state, set()).update(allowed_states)
for state in allowed... | python | {
"resource": ""
} |
q16923 | cmd_string | train | def cmd_string(name, cmd):
# type: (AName, ACmd) -> ADefine
"""Define a string parameter coming from a shell command to be used within
this YAML file. Trailing newlines will be stripped."""
value = subprocess.check_output(cmd, shell=True).rstrip("\n")
return Define(name, value) | python | {
"resource": ""
} |
q16924 | export_env_string | train | def export_env_string(name, value):
# type: (AEnvName, AEnvValue) -> ADefine
"""Exports an environment variable with the given value"""
os.environ[name] = value
return Define(name, value) | python | {
"resource": ""
} |
q16925 | WebsocketClientComms.on_message | train | def on_message(self, message):
"""Pass response from server to process receive queue
Args:
message(str): Received message
"""
# Called in tornado loop
try:
self.log.debug("Got message %s", message)
d = json_decode(message)
response... | python | {
"resource": ""
} |
q16926 | Info.filter_parts | train | def filter_parts(cls, part_info):
# type: (Type[T], PartInfo) -> Dict[str, List[T]]
"""Filter the part_info dict looking for instances of our class
Args:
part_info (dict): {part_name: [Info] or None} as returned from
Controller.run_hook()
Returns:
... | python | {
"resource": ""
} |
q16927 | Info.filter_values | train | def filter_values(cls, part_info):
# type: (Type[T], PartInfo) -> List[T]
"""Filter the part_info dict list looking for instances of our class
Args:
part_info (dict): {part_name: [Info] or None} as returned from
Controller.run_hook()
Returns:
lis... | python | {
"resource": ""
} |
q16928 | Info.filter_single_value | train | def filter_single_value(cls, part_info, error_msg=None):
# type: (Type[T], PartInfo, str) -> T
"""Filter the part_info dict list looking for a single instance of our
class
Args:
part_info (dict): {part_name: [Info] or None} as returned from
Controller.run_hoo... | python | {
"resource": ""
} |
q16929 | PvaServerComms.disconnect_pv_clients | train | def disconnect_pv_clients(self, mris):
# type: (List[str]) -> None
"""Disconnect anyone listening to any of the given mris"""
for mri in mris:
for pv in self._pvs.pop(mri, {}).values():
# Close pv with force destroy on, this will call
# onLastDisconnec... | python | {
"resource": ""
} |
q16930 | Port.with_source_port_tag | train | def with_source_port_tag(self, tags, connected_value):
"""Add a Source Port tag to the tags list, removing any other Source
Ports"""
new_tags = [t for t in tags if not t.startswith("sourcePort:")]
new_tags.append(self.source_port_tag(connected_value))
return new_tags | python | {
"resource": ""
} |
q16931 | Port.port_tag_details | train | def port_tag_details(cls, tags):
# type: (Sequence[str]) -> Union[Tuple[bool, Port, str], None]
"""Search tags for port info, returning it
Args:
tags: A list of tags to check
Returns:
None or (is_source, port, connected_value|disconnected_value)
wher... | python | {
"resource": ""
} |
q16932 | StatefulController.transition | train | def transition(self, state, message=""):
"""Change to a new state if the transition is allowed
Args:
state (str): State to transition to
message (str): Message if the transition is to a fault state
"""
with self.changes_squashed:
initial_state = self.... | python | {
"resource": ""
} |
q16933 | wait_for_stateful_block_init | train | def wait_for_stateful_block_init(context, mri, timeout=DEFAULT_TIMEOUT):
"""Wait until a Block backed by a StatefulController has initialized
Args:
context (Context): The context to use to make the child block
mri (str): The mri of the child block
timeout (float): The maximum time to wa... | python | {
"resource": ""
} |
q16934 | Future.exception | train | def exception(self, timeout=None):
"""Return the exception raised by the call that the future represents.
Args:
timeout: The number of seconds to wait for the exception if the
future isn't done. If None, then there is no limit on the wait
time.
Retur... | python | {
"resource": ""
} |
q16935 | Future.set_result | train | def set_result(self, result):
"""Sets the return value of work associated with the future.
Should only be used by Task and unit tests.
"""
self._result = result
self._state = self.FINISHED | python | {
"resource": ""
} |
q16936 | Future.set_exception | train | def set_exception(self, exception):
"""Sets the result of the future as being the given exception.
Should only be used by Task and unit tests.
"""
assert isinstance(exception, Exception), \
"%r should be an Exception" % exception
self._exception = exception
s... | python | {
"resource": ""
} |
q16937 | Request.return_response | train | def return_response(self, value=None):
# type: (Any) -> Tuple[Callback, Return]
"""Create a Return Response object to signal a return value"""
response = Return(id=self.id, value=value)
return self.callback, response | python | {
"resource": ""
} |
q16938 | Request.error_response | train | def error_response(self, exception):
# type: (Exception) -> Tuple[Callback, Error]
"""Create an Error Response object to signal an error"""
response = Error(id=self.id, message=exception)
log.exception("Exception raised for request %s", self)
return self.callback, response | python | {
"resource": ""
} |
q16939 | make_view | train | def make_view(controller, context, data):
# type: (Controller, Context, Any) -> Any
"""Make a View subclass containing properties specific for given data
Args:
controller (Controller): The child controller that hosts the data
context (Context): The context the parent has made that the View ... | python | {
"resource": ""
} |
q16940 | Attribute.put_value | train | def put_value(self, value, timeout=None):
"""Put a value to the Attribute and wait for completion"""
self._context.put(self._data.path + ["value"], value, timeout=timeout) | python | {
"resource": ""
} |
q16941 | ExposureDeadtimeInfo.calculate_exposure | train | def calculate_exposure(self, duration):
# type: (float) -> float
"""Calculate the exposure to set the detector to given the duration of
the frame and the readout_time and frequency_accuracy"""
exposure = duration - self.frequency_accuracy * duration / 1000000.0 - \
sel... | python | {
"resource": ""
} |
q16942 | Model.set_notifier_path | train | def set_notifier_path(self, notifier, path):
"""Sets the notifier, and the path from the path from block root
Args:
notifier (Notifier): The Notifier to tell when endpoint data changes
path (list): The absolute path to get to this object
"""
# type: (Union[Notifi... | python | {
"resource": ""
} |
q16943 | Model.apply_change | train | def apply_change(self, path, *args):
# type: (List[str], Any) -> None
"""Take a single change from a Delta and apply it to this model"""
if len(path) > 1:
# This is for a child
self[path[0]].apply_change(path[1:], *args)
else:
# This is for us
... | python | {
"resource": ""
} |
q16944 | VMeta.create_attribute_model | train | def create_attribute_model(self, initial_value=None):
# type: (Any) -> AttributeModel
"""Make an AttributeModel instance of the correct type for this Meta
Args:
initial_value: The initial value the Attribute should take
Returns:
AttributeModel: The created attri... | python | {
"resource": ""
} |
q16945 | VMeta.from_annotype | train | def from_annotype(cls, anno, writeable, **kwargs):
# type: (Anno, bool, **Any) -> VMeta
"""Return an instance of this class from an Anno"""
ret = cls(description=anno.description, writeable=writeable, **kwargs)
widget = ret.default_widget()
if widget != Widget.NONE:
r... | python | {
"resource": ""
} |
q16946 | VMeta.register_annotype_converter | train | def register_annotype_converter(cls, types, is_array=False,
is_mapping=False):
# type: (Union[Sequence[type], type], bool, bool) -> Any
"""Register this class as a converter for Anno instances"""
if not isinstance(types, Sequence):
types = [types]
... | python | {
"resource": ""
} |
q16947 | VMeta.lookup_annotype_converter | train | def lookup_annotype_converter(cls, anno):
# type: (Anno) -> Type[VMeta]
"""Look up a vmeta based on an Anno"""
if hasattr(anno.typ, "__bases__"):
# This is a proper type
bases = inspect.getmro(anno.typ)
else:
# This is a numpy dtype
bases =... | python | {
"resource": ""
} |
q16948 | AttributeModel.set_value | train | def set_value(self, value, set_alarm_ts=True, alarm=None, ts=None):
# type: (Any, bool, Alarm, TimeStamp) -> Any
"""Set value, calculating alarm and ts if requested"""
value = self.meta.validate(value)
if set_alarm_ts:
if alarm is None:
alarm = Alarm.ok
... | python | {
"resource": ""
} |
q16949 | AttributeModel.set_value_alarm_ts | train | def set_value_alarm_ts(self, value, alarm, ts):
"""Set value with pre-validated alarm and timeStamp"""
# type: (Any, Alarm, TimeStamp) -> None
with self.notifier.changes_squashed:
# Assume they are of the right format
self.value = value
self.notifier.add_squas... | python | {
"resource": ""
} |
q16950 | PandABlocksClient.send_recv | train | def send_recv(self, message, timeout=10.0):
"""Send a message to a PandABox and wait for the response
Args:
message (str): The message to send
timeout (float): How long to wait before raising queue.Empty
Returns:
str: The response
"""
respons... | python | {
"resource": ""
} |
q16951 | PandABlocksClient._send_loop | train | def _send_loop(self):
"""Service self._send_queue, sending requests to server"""
while True:
message, response_queue = self._send_queue.get()
if message is self.STOP:
break
try:
self._response_queues.put(response_queue)
... | python | {
"resource": ""
} |
q16952 | PandABlocksClient._respond | train | def _respond(self, resp):
"""Respond to the person waiting"""
response_queue = self._response_queues.get(timeout=0.1)
response_queue.put(resp)
self._completed_response_lines = []
self._is_multiline = None | python | {
"resource": ""
} |
q16953 | PandABlocksClient._recv_loop | train | def _recv_loop(self):
"""Service socket recv, returning responses to the correct queue"""
self._completed_response_lines = []
self._is_multiline = None
lines_iterator = self._get_lines()
while True:
try:
line = next(lines_iterator)
if s... | python | {
"resource": ""
} |
q16954 | PandABlocksClient.parameterized_send | train | def parameterized_send(self, request, parameter_list):
"""Send batched requests for a list of parameters
Args:
request (str): Request to send, like "%s.*?\n"
parameter_list (list): parameters to format with, like
["TTLIN", "TTLOUT"]
Returns:
... | python | {
"resource": ""
} |
q16955 | ChildPart.notify_dispatch_request | train | def notify_dispatch_request(self, request):
# type: (Request) -> None
"""Will be called when a context passed to a hooked function is about
to dispatch a request"""
if isinstance(request, Put) and request.path[0] == self.mri:
# This means the context we were passed has just m... | python | {
"resource": ""
} |
q16956 | ChildPart.sever_sink_ports | train | def sever_sink_ports(self, context, ports, connected_to=None):
# type: (AContext, APortMap, str) -> None
"""Conditionally sever Sink Ports of the child. If connected_to
is then None then sever all, otherwise restrict to connected_to's
Source Ports
Args:
context (Cont... | python | {
"resource": ""
} |
q16957 | ChildPart.calculate_part_visibility | train | def calculate_part_visibility(self, ports):
# type: (APortMap) -> None
"""Calculate what is connected to what
Args:
ports: {part_name: [PortInfo]} from other ports
"""
# Calculate a lookup of Source Port connected_value to part_name
source_port_lookup = {}
... | python | {
"resource": ""
} |
q16958 | Notifier.handle_subscribe | train | def handle_subscribe(self, request):
# type: (Subscribe) -> CallbackResponses
"""Handle a Subscribe request from outside. Called with lock taken"""
ret = self._tree.handle_subscribe(request, request.path[1:])
self._subscription_keys[request.generate_key()] = request
return ret | python | {
"resource": ""
} |
q16959 | Notifier.handle_unsubscribe | train | def handle_unsubscribe(self, request):
# type: (Unsubscribe) -> CallbackResponses
"""Handle a Unsubscribe request from outside. Called with lock taken"""
subscribe = self._subscription_keys.pop(request.generate_key())
ret = self._tree.handle_unsubscribe(subscribe, subscribe.path[1:])
... | python | {
"resource": ""
} |
q16960 | Notifier.add_squashed_change | train | def add_squashed_change(self, path, data):
# type: (List[str], Any) -> None
"""Register a squashed change to a particular path
Args:
path (list): The path of what has changed, relative from Block
data (object): The new data
"""
assert self._squashed_count... | python | {
"resource": ""
} |
q16961 | NotifierNode.notify_changes | train | def notify_changes(self, changes):
# type: (List[List]) -> CallbackResponses
"""Set our data and notify anyone listening
Args:
changes (list): [[path, optional data]] where path is the path to
what has changed, and data is the unserialized object that has
... | python | {
"resource": ""
} |
q16962 | NotifierNode._update_data | train | def _update_data(self, data):
# type: (Any) -> Dict[str, List]
"""Set our data and notify any subscribers of children what has changed
Args:
data (object): The new data
Returns:
dict: {child_name: [path_list, optional child_data]} of the change
t... | python | {
"resource": ""
} |
q16963 | NotifierNode.handle_subscribe | train | def handle_subscribe(self, request, path):
# type: (Subscribe, List[str]) -> CallbackResponses
"""Add to the list of request to notify, and notify the initial value of
the data held
Args:
request (Subscribe): The subscribe request
path (list): The relative path f... | python | {
"resource": ""
} |
q16964 | NotifierNode.handle_unsubscribe | train | def handle_unsubscribe(self, request, path):
# type: (Subscribe, List[str]) -> CallbackResponses
"""Remove from the notifier list and send a return
Args:
request (Subscribe): The original subscribe request
path (list): The relative path from ourself
Returns:
... | python | {
"resource": ""
} |
q16965 | string | train | def string(name, description, default=None):
# type: (AName, ADescription, AStringDefault) -> AAnno
"""Add a string parameter to be passed when instantiating this YAML file"""
args = common_args(name, default)
return Anno(description, typ=str, **args) | python | {
"resource": ""
} |
q16966 | float64 | train | def float64(name, description, default=None):
# type: (AName, ADescription, AFloat64Default) -> AAnno
"""Add a float64 parameter to be passed when instantiating this YAML file"""
args = common_args(name, default)
return Anno(description, typ=float, **args) | python | {
"resource": ""
} |
q16967 | int32 | train | def int32(name, description, default=None):
# type: (AName, ADescription, AInt32Default) -> AAnno
"""Add an int32 parameter to be passed when instantiating this YAML file"""
args = common_args(name, default)
return Anno(description, typ=int, **args) | python | {
"resource": ""
} |
q16968 | make_block_creator | train | def make_block_creator(yaml_path, filename=None):
# type: (str, str) -> Callable[..., List[Controller]]
"""Make a collection function that will create a list of blocks
Args:
yaml_path (str): File path to YAML file, or a file in the same dir
filename (str): If give, use this filename as the ... | python | {
"resource": ""
} |
q16969 | Section.instantiate | train | def instantiate(self, substitutions):
"""Keep recursing down from base using dotted name, then call it with
self.params and args
Args:
substitutions (dict): Substitutions to make to self.param_dict
Returns:
The found object called with (*args, map_from_d)
... | python | {
"resource": ""
} |
q16970 | Section.from_yaml | train | def from_yaml(cls, yaml_path, filename=None):
"""Split a dictionary into parameters controllers parts blocks defines
Args:
yaml_path (str): File path to YAML file, or a file in the same dir
filename (str): If give, use this filename as the last element in
the yam... | python | {
"resource": ""
} |
q16971 | Section.substitute_params | train | def substitute_params(self, substitutions):
"""Substitute param values in our param_dict from params
Args:
substitutions (Map or dict): Values to substitute. E.g. Map of
{"name": "me"}
E.g. if self.param_dict is:
{"name": "$(name):pos", "exposure": 1.0}
... | python | {
"resource": ""
} |
q16972 | MotorInfo.make_velocity_profile | train | def make_velocity_profile(self, v1, v2, distance, min_time):
"""Calculate PVT points that will perform the move within motor params
Args:
v1 (float): Starting velocity in EGUs/s
v2 (float): Ending velocity in EGUs/s
distance (float): Relative distance to travel in EG... | python | {
"resource": ""
} |
q16973 | MotorInfo.cs_axis_mapping | train | def cs_axis_mapping(cls,
part_info, # type: Dict[str, Optional[Sequence]]
axes_to_move # type: Sequence[str]
):
# type: (...) -> Tuple[str, Dict[str, MotorInfo]]
"""Given the motor infos for the parts, filter those with scannable
... | python | {
"resource": ""
} |
q16974 | ManagerController.set_layout | train | def set_layout(self, value):
"""Set the layout table value. Called on attribute put"""
# Can't do this with changes_squashed as it will call update_modified
# from another thread and deadlock. Need RLock.is_owned() from update_*
part_info = self.run_hooks(
LayoutHook(p, c, se... | python | {
"resource": ""
} |
q16975 | ManagerController.save | train | def save(self, designName=""):
# type: (ASaveDesign) -> None
"""Save the current design to file"""
self.try_stateful_function(
ss.SAVING, ss.READY, self.do_save, designName) | python | {
"resource": ""
} |
q16976 | ManagerController._validated_config_filename | train | def _validated_config_filename(self, name):
"""Make config dir and return full file path and extension
Args:
name (str): Filename without dir or extension
Returns:
str: Full path including extension
"""
dir_name = self._make_config_dir()
filename... | python | {
"resource": ""
} |
q16977 | ManagerController.do_load | train | def do_load(self, design, init=False):
# type: (str, bool) -> None
"""Load a design name, running the child LoadHooks.
Args:
design: Name of the design json file, without extension
init: Passed to the LoadHook to tell the children if this is being
run at ... | python | {
"resource": ""
} |
q16978 | FieldRegistry.add_method_model | train | def add_method_model(self,
func, # type: Callable
name=None, # type: Optional[str]
description=None, # type: Optional[str]
owner=None, # type: object
):
# type: (...) -> MethodModel
... | python | {
"resource": ""
} |
q16979 | PartRegistrar.add_method_model | train | def add_method_model(self,
func, # type: Callable
name=None, # type: Optional[str]
description=None, # type: Optional[str]
):
# type: (...) -> MethodModel
"""Register a function to be added to the Bloc... | python | {
"resource": ""
} |
q16980 | PartRegistrar.add_attribute_model | train | def add_attribute_model(self,
name, # type: str
attr, # type: AttributeModel
writeable_func=None, # type: Optional[Callable]
):
# type: (...) -> AttributeModel
"""Register a pre-existing At... | python | {
"resource": ""
} |
q16981 | MOProblem.objective_bounds | train | def objective_bounds(self):
"""
Return objective bounds
Returns
-------
lower : list of floats
Lower boundaries for the objectives
Upper : list of floats
Upper boundaries for the objectives
"""
if self.ideal and self.nadir:
... | python | {
"resource": ""
} |
q16982 | _centroids | train | def _centroids(n_clusters: int, points: List[List[float]]) -> List[List[float]]:
""" Return n_clusters centroids of points
"""
k_means = KMeans(n_clusters=n_clusters)
k_means.fit(points)
closest, _ = pairwise_distances_argmin_min(k_means.cluster_centers_, points)
return list(map(list, np.arra... | python | {
"resource": ""
} |
q16983 | new_points | train | def new_points(
factory: IterationPointFactory, solution, weights: List[List[float]] = None
) -> List[Tuple[np.ndarray, List[float]]]:
"""Generate approximate set of points
Generate set of Pareto optimal solutions projecting from the Pareto optimal solution
using weights to determine the direction.
... | python | {
"resource": ""
} |
q16984 | as_minimized | train | def as_minimized(values: List[float], maximized: List[bool]) -> List[float]:
""" Return vector values as minimized
"""
return [v * -1. if m else v for v, m in zip(values, maximized)] | python | {
"resource": ""
} |
q16985 | _prompt_wrapper | train | def _prompt_wrapper(message, default=None, validator=None):
""" Handle references piped from file
"""
class MockDocument:
def __init__(self, text):
self.text = text
if HAS_INPUT:
ret = prompt(message, default=default, validator=validator)
else:
ret = sys.stdin.... | python | {
"resource": ""
} |
q16986 | init_nautilus | train | def init_nautilus(method):
"""Initialize nautilus method
Parameters
----------
method
Interactive method used for the process
Returns
-------
PreferenceInformation subclass to be initialized
"""
print("Preference elicitation options:")
print("\t1 - Percentages")
... | python | {
"resource": ""
} |
q16987 | iter_nautilus | train | def iter_nautilus(method):
""" Iterate NAUTILUS method either interactively, or using given preferences if given
Parameters
----------
method : instance of NAUTILUS subclass
Fully initialized NAUTILUS method instance
"""
solution = None
while method.current_iter:
preference... | python | {
"resource": ""
} |
q16988 | isin | train | def isin(value, values):
""" Check that value is in values """
for i, v in enumerate(value):
if v not in np.array(values)[:, i]:
return False
return True | python | {
"resource": ""
} |
q16989 | NIMBUS.between | train | def between(self, objs1: List[float], objs2: List[float], n=1):
"""
Generate `n` solutions which attempt to trade-off `objs1` and `objs2`.
Parameters
----------
objs1
First boundary point for desired objective function values
objs2
Second boundar... | python | {
"resource": ""
} |
q16990 | find_focusable | train | def find_focusable(node):
"""
Search for the first focusable window within the node tree
"""
if not node.children:
return node
if node.focus:
return find_focusable(node.children_dict[node.focus[0]]) | python | {
"resource": ""
} |
q16991 | find_parent_split | train | def find_parent_split(node, orientation):
"""
Find the first parent split relative to the given node
according to the desired orientation
"""
if (node and node.orientation == orientation
and len(node.children) > 1):
return node
if not node or node.type == "workspace":
r... | python | {
"resource": ""
} |
q16992 | cycle_windows | train | def cycle_windows(tree, direction):
"""
Cycle through windows of the current workspace
"""
wanted = {
"orientation": ("vertical" if direction in ("up", "down")
else "horizontal"),
"direction": (1 if direction in ("down", "right")
else -1),
... | python | {
"resource": ""
} |
q16993 | cycle_outputs | train | def cycle_outputs(tree, direction):
"""
Cycle through directions
"""
direction = 1 if direction == "next" else -1
outputs = [output for output in tree.root.children
if output.name != "__i3"]
focus_idx = outputs.index(tree.root.focused_child)
next_idx = (focus_idx + direction) ... | python | {
"resource": ""
} |
q16994 | NIMBUSClassification.with_class | train | def with_class(self, cls):
""" Return functions with the class
"""
rcls = []
for key, value in self._classification.items():
if value[0] == cls:
rcls.append(key)
return rcls | python | {
"resource": ""
} |
q16995 | NIMBUSClassification._as_reference_point | train | def _as_reference_point(self) -> np.ndarray:
""" Return classification information as reference point
"""
ref_val = []
for fn, f in self._classification.items():
if f[0] == "<":
ref_val.append(self._method.problem.ideal[fn])
elif f[0] == "<>":
... | python | {
"resource": ""
} |
q16996 | main | train | def main(logfile=False):
""" Solve River Pollution problem with NAUTILUS V1 and E-NAUTILUS Methods
"""
# Duplicate output to log file
class NAUTILUSOptionValidator(Validator):
def validate(self, document):
if document.text not in "ao":
raise ValidationError(
... | python | {
"resource": ""
} |
q16997 | setup | train | def setup(app):
"""Setup connects events to the sitemap builder"""
app.add_config_value(
'site_url',
default=None,
rebuild=False
)
try:
app.add_config_value(
'html_baseurl',
default=None,
rebuild=False
)
except:
pass... | python | {
"resource": ""
} |
q16998 | OptimizationMethod.search | train | def search(self, max=False, **params) -> Tuple[np.ndarray, List[float]]:
"""
Search for the optimal solution
This sets up the search for the optimization and calls the _search method
Parameters
----------
max : bool (default False)
If true find mximum of the... | python | {
"resource": ""
} |
q16999 | NAUTILUSv1.next_iteration | train | def next_iteration(self, preference=None):
"""
Return next iteration bounds
"""
if preference:
self.preference = preference
print(("Given preference: %s" % self.preference.pref_input))
self._update_fh()
# tmpzh = list(self.zh)
self._update... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.