_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q9500 | BundleCompleter.complete | train | def complete(
self, config, prompt, session, context, current_arguments, current
):
# type: (CompletionInfo, str, ShellSession, BundleContext, List[str], str) -> List[str]
"""
Returns the list of bundle IDs matching the current state
:param config: Configuration of the current completion
:param prompt: Shell prompt (for re-display)
:param session: Shell session (to display in shell)
:param context: Bundle context of the Shell bundle
:param current_arguments: Current arguments (without the command itself)
:param current: Current word
:return: A list of matches
"""
# Register a method to display helpful completion | python | {
"resource": ""
} |
q9501 | Container.is_valid | train | def is_valid(self):
# type: () -> bool
"""
Checks if the component is valid
:return: Always True if it doesn't raise an exception
:raises AssertionError: Invalid properties
"""
assert self._bundle_context
assert self._container_props is not None
| python | {
"resource": ""
} |
q9502 | Container._add_export | train | def _add_export(self, ed_id, inst):
# type: (str, Tuple[Any, EndpointDescription]) -> None
"""
Keeps track of an exported service
| python | {
"resource": ""
} |
q9503 | Container._find_export | train | def _find_export(self, func):
# type: (Callable[[Tuple[Any, EndpointDescription]], bool]) -> Optional[Tuple[Any, EndpointDescription]]
"""
Look for an export using the given lookup method
The lookup method must accept a single parameter, which is a tuple
containing a service instance and endpoint description.
:param func: A function to look for the | python | {
"resource": ""
} |
q9504 | ExportContainer._export_service | train | def _export_service(self, svc, ed):
# type: (Any, EndpointDescription) -> None
"""
Registers a service export
:param svc: Service instance
| python | {
"resource": ""
} |
q9505 | ExportContainer.prepare_endpoint_props | train | def prepare_endpoint_props(self, intfs, svc_ref, export_props):
# type: (List[str], ServiceReference, Dict[str, Any]) -> Dict[str, Any]
"""
Sets up the properties of an endpoint
:param intfs: Specifications to export
:param svc_ref: Reference of the exported service
:param export_props: Export properties
:return: The properties of the endpoint
"""
pkg_vers = rsa.get_package_versions(intfs, export_props)
exported_configs = get_string_plus_property_value(
svc_ref.get_property(SERVICE_EXPORTED_CONFIGS)
)
if not exported_configs:
exported_configs = [self.get_config_name()]
service_intents = set()
svc_intents = export_props.get(SERVICE_INTENTS, None)
if svc_intents:
service_intents.update(svc_intents)
svc_exp_intents = export_props.get(SERVICE_EXPORTED_INTENTS, None)
if svc_exp_intents:
service_intents.update(svc_exp_intents)
svc_exp_intents_extra = export_props.get(
SERVICE_EXPORTED_INTENTS_EXTRA, None
)
if svc_exp_intents_extra:
service_intents.update(svc_exp_intents_extra)
rsa_props = rsa.get_rsa_props(
intfs,
exported_configs,
| python | {
"resource": ""
} |
q9506 | ExportContainer.export_service | train | def export_service(self, svc_ref, export_props):
# type: (ServiceReference, Dict[str, Any]) -> EndpointDescription
"""
Exports the given service
:param svc_ref: Reference to the service to export
:param export_props: Export properties
:return: The endpoint description
| python | {
"resource": ""
} |
q9507 | _FactoryCounter.get_service | train | def get_service(self, factory, svc_registration):
# type: (Any, ServiceRegistration) -> Any
"""
Returns the service required by the bundle. The Service Factory is
called only when necessary while the Prototype Service Factory is
called each time
:param factory: The service factory
:param svc_registration: The ServiceRegistration object
| python | {
"resource": ""
} |
q9508 | _FactoryCounter.unget_service | train | def unget_service(self, factory, svc_registration, service=None):
# type: (Any, ServiceRegistration, Any) -> bool
"""
Releases references to the given service reference
:param factory: The service factory
:param svc_registration: The ServiceRegistration object
:param service: Service instance (for prototype factories)
:return: True if all service references to this service factory
have been released
"""
svc_ref = svc_registration.get_reference()
try:
_, counter = self.__factored[svc_ref]
except KeyError:
logging.warning(
"Trying to release an unknown service factory: %s", svc_ref
)
else:
if svc_ref.is_prototype():
# Notify the factory to clean up this instance
factory.unget_service_instance(
| python | {
"resource": ""
} |
q9509 | _FactoryCounter.cleanup_service | train | def cleanup_service(self, factory, svc_registration):
# type: (Any, ServiceRegistration) -> bool
"""
If this bundle used that factory, releases the reference; else does
nothing
:param factory: The service factory
:param svc_registration: The ServiceRegistration object
:return: True if the bundle was using the factory, else False
"""
svc_ref = svc_registration.get_reference()
try:
# "service" for factories, "services" for prototypes
services, _ = self.__factored.pop(svc_ref)
except KeyError:
return False
else:
if svc_ref.is_prototype() and services:
for service in services:
try:
factory.unget_service_instance(
| python | {
"resource": ""
} |
q9510 | ServiceReference.unused_by | train | def unused_by(self, bundle):
"""
Indicates that this reference is not being used anymore by the given
bundle.
This method should only be used by the framework.
:param bundle: A bundle that used this reference
"""
if bundle is None or bundle is self.__bundle:
# Ignore
return
with self.__usage_lock:
try:
if | python | {
"resource": ""
} |
q9511 | ServiceReference.used_by | train | def used_by(self, bundle):
"""
Indicates that this reference is being used by the given bundle.
This method should only be used by the framework.
:param bundle: A bundle using this reference
"""
if bundle is None or bundle is self.__bundle: | python | {
"resource": ""
} |
q9512 | ServiceRegistration.set_properties | train | def set_properties(self, properties):
"""
Updates the service properties
:param properties: The new properties
:raise TypeError: The argument is not a dictionary
"""
if not isinstance(properties, dict):
raise TypeError("Waiting for dictionary")
# Keys that must not be updated
for forbidden_key in OBJECTCLASS, SERVICE_ID:
try:
del properties[forbidden_key]
except KeyError:
pass
to_delete = []
for key, value in properties.items():
if self.__properties.get(key) == value:
# No update
to_delete.append(key)
for key in to_delete:
# Remove unchanged properties
del properties[key]
if not properties:
# Nothing to do
return
# Ensure that the service has a valid service ranking
try:
properties[SERVICE_RANKING] = int(properties[SERVICE_RANKING])
except (ValueError, TypeError):
# Bad value: ignore update
del properties[SERVICE_RANKING]
| python | {
"resource": ""
} |
q9513 | EventDispatcher.clear | train | def clear(self):
"""
Clears the event dispatcher
"""
with self.__bnd_lock:
| python | {
"resource": ""
} |
q9514 | EventDispatcher.add_bundle_listener | train | def add_bundle_listener(self, listener):
"""
Adds a bundle listener
:param listener: The bundle listener to register
:return: True if the listener has been registered, False if it was
already known
:raise BundleException: An invalid listener has been given
| python | {
"resource": ""
} |
q9515 | EventDispatcher.add_framework_listener | train | def add_framework_listener(self, listener):
"""
Registers a listener that will be called back right before the
framework stops.
:param listener: The framework stop listener
:return: True if the listener has been registered, False if it was
already known
:raise BundleException: An invalid listener has been given
"""
if listener is None or not hasattr(listener, "framework_stopping"):
raise BundleException("Invalid framework listener given")
with self.__fw_lock:
if listener | python | {
"resource": ""
} |
q9516 | EventDispatcher.remove_bundle_listener | train | def remove_bundle_listener(self, listener):
"""
Unregisters a bundle listener
:param listener: The bundle listener to unregister
:return: True if the listener has been unregistered, else False
"""
with self.__bnd_lock:
| python | {
"resource": ""
} |
q9517 | EventDispatcher.remove_framework_listener | train | def remove_framework_listener(self, listener):
"""
Unregisters a framework stop listener
:param listener: The framework listener to unregister
:return: True if the listener has been unregistered, else False
"""
with self.__fw_lock:
| python | {
"resource": ""
} |
q9518 | EventDispatcher.remove_service_listener | train | def remove_service_listener(self, listener):
"""
Unregisters a service listener
:param listener: The service listener
:return: True if the listener has been unregistered
"""
with self.__svc_lock:
try:
data = self.__listeners_data.pop(listener)
| python | {
"resource": ""
} |
q9519 | EventDispatcher.fire_bundle_event | train | def fire_bundle_event(self, event):
"""
Notifies bundle events listeners of a new event in the calling thread.
:param event: The bundle event
"""
with self.__bnd_lock:
# Copy the list of listeners
listeners = self.__bnd_listeners[:]
| python | {
"resource": ""
} |
q9520 | EventDispatcher.fire_framework_stopping | train | def fire_framework_stopping(self):
"""
Calls all framework listeners, telling them that the framework is
stopping
"""
with self.__fw_lock:
# Copy the list of listeners
| python | {
"resource": ""
} |
q9521 | EventDispatcher.fire_service_event | train | def fire_service_event(self, event):
"""
Notifies service events listeners of a new event in the calling thread.
:param event: The service event
"""
# Get the service properties
properties = event.get_service_reference().get_properties()
svc_specs = properties[OBJECTCLASS]
previous = None
endmatch_event = None
svc_modified = event.get_kind() == ServiceEvent.MODIFIED
if svc_modified:
# Modified service event : prepare the end match event
previous = event.get_previous_properties()
endmatch_event = ServiceEvent(
ServiceEvent.MODIFIED_ENDMATCH,
event.get_service_reference(),
previous,
)
with self.__svc_lock:
# Get the listeners for this specification
listeners = set()
for spec in svc_specs:
try:
| python | {
"resource": ""
} |
q9522 | EventDispatcher._filter_with_hooks | train | def _filter_with_hooks(self, svc_event, listeners):
"""
Filters listeners with EventListenerHooks
:param svc_event: ServiceEvent being triggered
:param listeners: Listeners to filter
:return: A list of listeners with hook references
"""
svc_ref = svc_event.get_service_reference()
# Get EventListenerHooks service refs from registry
hook_refs = self._registry.find_service_references(
SERVICE_EVENT_LISTENER_HOOK
)
# only do something if there are some hook_refs
if hook_refs:
# Associate bundle context to hooks
ctx_listeners = {}
for listener in listeners:
context = listener.bundle_context
ctx_listeners.setdefault(context, []).append(listener)
# Convert the dictionary to a shrinkable one,
# with shrinkable lists of listeners
shrinkable_ctx_listeners = ShrinkableMap(
{
context: ShrinkableList(value)
for context, value in ctx_listeners.items()
}
)
for hook_ref in hook_refs:
if not svc_ref == hook_ref:
# Get the bundle of the hook service
hook_bundle = hook_ref.get_bundle()
# lookup service from registry
hook_svc = self._registry.get_service(hook_bundle, hook_ref)
if hook_svc is not None:
# call event method of the hook service,
| python | {
"resource": ""
} |
q9523 | ServiceRegistry.clear | train | def clear(self):
"""
Clears the registry
"""
with self.__svc_lock:
self.__svc_registry.clear()
self.__svc_factories.clear()
self.__svc_specs.clear()
self.__bundle_svc.clear()
| python | {
"resource": ""
} |
q9524 | ServiceRegistry.__sort_registry | train | def __sort_registry(self, svc_ref):
# type: (ServiceReference) -> None
"""
Sorts the registry, after the update of the sort key of given service
reference
:param svc_ref: A service reference with a modified sort key
"""
with self.__svc_lock:
if svc_ref not in self.__svc_registry:
raise BundleException("Unknown service: {0}".format(svc_ref))
# Remove current references
for spec in svc_ref.get_property(OBJECTCLASS):
# Use bisect to remove the reference (faster)
| python | {
"resource": ""
} |
q9525 | ServiceRegistry.unregister | train | def unregister(self, svc_ref):
# type: (ServiceReference) -> Any
"""
Unregisters a service
:param svc_ref: A service reference
:return: The unregistered service instance
:raise BundleException: Unknown service reference
"""
with self.__svc_lock:
try:
# Try in pending services
return self.__pending_services.pop(svc_ref)
except KeyError:
# Not pending: continue
pass
if svc_ref not in self.__svc_registry:
raise BundleException("Unknown service: {0}".format(svc_ref))
# Get the owner
bundle = svc_ref.get_bundle()
# Get the service instance
service = self.__svc_registry.pop(svc_ref)
for spec in svc_ref.get_property(OBJECTCLASS):
spec_services = self.__svc_specs[spec]
# Use bisect to remove the reference (faster)
idx = bisect.bisect_left(spec_services, svc_ref)
del spec_services[idx]
if not spec_services:
| python | {
"resource": ""
} |
q9526 | ServiceRegistry.get_bundle_imported_services | train | def get_bundle_imported_services(self, bundle):
"""
Returns this bundle's ServiceReference list for all services it is
using or returns None if this bundle is not using any services.
A bundle is considered to be using a service if its use count for that
service is greater than zero.
The list is valid at the time of the call to this method, however, as
| python | {
"resource": ""
} |
q9527 | ServiceRegistry.get_bundle_registered_services | train | def get_bundle_registered_services(self, bundle):
# type: (Any) -> List[ServiceReference]
"""
Retrieves the services registered by the given bundle. Returns None
if the bundle didn't register any service.
:param bundle: The bundle to look into
| python | {
"resource": ""
} |
q9528 | ServiceRegistry.__get_service_from_factory | train | def __get_service_from_factory(self, bundle, reference):
# type: (Any, ServiceReference) -> Any
"""
Returns a service instance from a service factory or a prototype
service factory
:param bundle: The bundle requiring the service
:param reference: A reference pointing to a factory
:return: The requested service
:raise BundleException: The service could not be found
"""
try:
factory, svc_reg = self.__svc_factories[reference]
# Indicate the dependency
imports = self.__bundle_imports.setdefault(bundle, {})
if reference not in imports:
# New reference usage: store a single usage
# The Factory counter will handle the rest
usage_counter = _UsageCounter()
usage_counter.inc()
imports[reference] = usage_counter
| python | {
"resource": ""
} |
q9529 | ServiceRegistry.unget_used_services | train | def unget_used_services(self, bundle):
"""
Cleans up all service usages of the given bundle.
:param bundle: Bundle to be cleaned up
"""
# Pop used references
try:
imported_refs = list(self.__bundle_imports.pop(bundle))
except KeyError:
# Nothing to do
return
for svc_ref in imported_refs:
# Remove usage marker
svc_ref.unused_by(bundle)
if svc_ref.is_prototype():
# Get factory information and clean up the service from the
# factory counter
factory_counter = self.__factory_usage.pop(bundle)
| python | {
"resource": ""
} |
q9530 | ServiceRegistry.unget_service | train | def unget_service(self, bundle, reference, service=None):
# type: (Any, ServiceReference, Any) -> bool
"""
Removes the usage of a service by a bundle
:param bundle: The bundle that used the service
:param reference: A service reference
:param service: Service instance (for Prototype Service Factories)
:return: True if the bundle usage has been removed
"""
with self.__svc_lock:
if reference.is_prototype():
return self.__unget_service_from_factory(
bundle, reference, service
)
elif reference.is_factory():
return self.__unget_service_from_factory(bundle, reference)
try:
# Remove the service reference from the bundle
imports = self.__bundle_imports[bundle]
| python | {
"resource": ""
} |
q9531 | ServiceRegistry.__unget_service_from_factory | train | def __unget_service_from_factory(self, bundle, reference, service=None):
# type: (Any, ServiceReference, Any) -> bool
"""
Removes the usage of a a service factory or a prototype
service factory by a bundle
:param bundle: The bundle that used the service
:param reference: A service reference
:param service: Service instance (for prototype factories)
:return: True if the bundle usage has been removed
"""
try:
factory, svc_reg = self.__svc_factories[reference]
except KeyError:
# Unknown service reference
return False
# Check the per-bundle usage counter
try:
counter = self.__factory_usage[bundle]
except KeyError:
# Unknown reference to a factory
return False
else:
if counter.unget_service(factory, svc_reg, service):
try:
# No more dependency
| python | {
"resource": ""
} |
q9532 | EDEFReader._convert_value | train | def _convert_value(vtype, value):
"""
Converts the given value string according to the given type
:param vtype: Type of the value
:param value: String form of the value
:return: The converted value
:raise ValueError: Conversion failed
"""
# Normalize value
value = value.strip()
if vtype == TYPE_STRING:
# Nothing to do
return value
elif vtype in TYPES_INT:
return int(value)
| python | {
"resource": ""
} |
q9533 | EDEFWriter._indent | train | def _indent(self, element, level=0, prefix="\t"):
"""
In-place Element text auto-indent, for pretty printing.
Code from: http://effbot.org/zone/element-lib.htm#prettyprint
:param element: An Element object
:param level: Level of indentation
:param prefix: String to use for each indentation
"""
element_prefix = "\r\n{0}".format(level * prefix)
if len(element):
if not element.text or not element.text.strip():
element.text = element_prefix + prefix
if not element.tail or not element.tail.strip():
element.tail = element_prefix
| python | {
"resource": ""
} |
q9534 | EDEFWriter._add_container | train | def _add_container(props_node, tag, container):
"""
Walks through the given container and fills the node
:param props_node: A property node
:param tag: Name of the container tag
:param container: The container
"""
values_node = ElementTree.SubElement(props_node, | python | {
"resource": ""
} |
q9535 | EDEFWriter._get_type | train | def _get_type(name, value):
"""
Returns the type associated to the given name or value
:param name: Property name
:param value: Property value
:return: A value type name
"""
# Types forced for known keys
if name in TYPED_BOOL:
return TYPE_BOOLEAN
elif name in TYPED_LONG:
return TYPE_LONG
elif name in TYPED_STRING:
return TYPE_STRING
# We need to analyze the content of value
if isinstance(value, (tuple, list, set)):
# Get the type from container content
try:
# Extract value
value = next(iter(value))
except StopIteration:
# Empty list, can't check
return TYPE_STRING
| python | {
"resource": ""
} |
q9536 | BasicBot.on_session_start | train | def on_session_start(self, data):
# pylint: disable=W0613
"""
XMPP session started
"""
# | python | {
"resource": ""
} |
q9537 | InviteMixIn.on_invite | train | def on_invite(self, data):
"""
Multi-User Chat invite
"""
if not self._nick:
self._nick = self.boundjid.user
| python | {
"resource": ""
} |
q9538 | ServiceDiscoveryMixin.iter_services | train | def iter_services(self, feature=None):
"""
Iterates over the root-level services on the server which provides the
requested feature
:param feature: Feature that the service must provide (optional)
:return: A generator of services JID
"""
# Get the list of root services
items = self["xep_0030"].get_items(
jid=self.boundjid.domain,
ifrom=self.boundjid.full,
block=True,
timeout=10,
)
for item in items["disco_items"]["items"]:
# Each item is a 3-tuple. The service JID is the first entry
if not feature:
# No filter
yield item[0]
else:
# Get | python | {
"resource": ""
} |
q9539 | _find_assignment | train | def _find_assignment(arg_token):
"""
Find the first non-escaped assignment in the given argument token.
Returns -1 if no assignment was found.
:param arg_token: The argument token
:return: The index of the first assignment, or -1
"""
idx = arg_token.find("=")
while idx != -1:
| python | {
"resource": ""
} |
q9540 | _split_ns_command | train | def _split_ns_command(cmd_token):
"""
Extracts the name space and the command name of the given command token.
:param cmd_token: The command token
:return: The extracted (name space, command) tuple
"""
namespace = None
cmd_split = cmd_token.split(".", 1)
if len(cmd_split) == 1:
# No name space given
command = cmd_split[0]
else:
# Got a name space and a command
namespace = cmd_split[0]
| python | {
"resource": ""
} |
q9541 | Shell.register_command | train | def register_command(self, namespace, command, method):
"""
Registers the given command to the shell.
The namespace can be None, empty or "default"
:param namespace: The command name space.
:param command: The shell name of the command
:param method: The method to call
:return: True if the method has been registered, False if it was
already known or invalid
"""
if method is None:
self._logger.error("No method given for %s.%s", namespace, command)
| python | {
"resource": ""
} |
q9542 | Shell.get_command_completers | train | def get_command_completers(self, namespace, command):
# type: (str, str) -> CompletionInfo
"""
Returns the completer method associated to the given command, or None
:param namespace: The command name space.
:param command: The shell name of the command
:return: A CompletionConfiguration object
:raise KeyError: Unknown | python | {
"resource": ""
} |
q9543 | Shell.unregister | train | def unregister(self, namespace, command=None):
"""
Unregisters the given command. If command is None, the whole name space
is unregistered.
:param namespace: The command name space.
:param command: The shell name of the command, or None
:return: True if the command was known, else False
"""
if not namespace:
namespace = DEFAULT_NAMESPACE
namespace = namespace.strip().lower()
if namespace not in self._commands:
| python | {
"resource": ""
} |
q9544 | Shell.__find_command_ns | train | def __find_command_ns(self, command):
"""
Returns the name spaces where the given command named is registered.
If the command exists in the default name space, the returned list will
only contain the default name space.
Returns an empty list of the command is unknown
:param command: A command name
:return: A list of name spaces
"""
# Look for the spaces where the command name appears
namespaces = []
for namespace, commands in self._commands.items():
if command in commands:
| python | {
"resource": ""
} |
q9545 | Shell.get_ns_commands | train | def get_ns_commands(self, cmd_name):
"""
Retrieves the possible name spaces and commands associated to the given
command name.
:param cmd_name: The given command name
:return: A list of 2-tuples (name space, command)
:raise ValueError: Unknown command name
"""
namespace, command = _split_ns_command(cmd_name)
if not namespace:
# Name space not given, look for the commands
spaces = self.__find_command_ns(command)
if not spaces:
| python | {
"resource": ""
} |
q9546 | Shell.get_ns_command | train | def get_ns_command(self, cmd_name):
"""
Retrieves the name space and the command associated to the given
command name.
:param cmd_name: The given command name
:return: A 2-tuple (name space, command)
:raise ValueError: Unknown command name
"""
namespace, command = _split_ns_command(cmd_name)
if not namespace:
# Name space not given, look for the command
spaces = self.__find_command_ns(command)
if not spaces:
# Unknown command
raise ValueError("Unknown command {0}".format(command))
elif len(spaces) > 1:
# Multiple possibilities
if spaces[0] == DEFAULT_NAMESPACE:
# Default name space has priority
namespace = DEFAULT_NAMESPACE
| python | {
"resource": ""
} |
q9547 | Shell.execute | train | def execute(self, cmdline, session=None):
"""
Executes the command corresponding to the given line
:param cmdline: Command line to parse
:param session: Current shell session
:return: True if command succeeded, else False
"""
if session is None:
# Default session
session = beans.ShellSession(
beans.IOHandler(sys.stdin, sys.stdout), {}
)
assert isinstance(session, beans.ShellSession)
# Split the command line
if not cmdline:
return False
# Convert the line into a string
cmdline = to_str(cmdline)
try:
line_split = shlex.split(cmdline, True, True)
except ValueError as ex:
session.write_line("Error reading line: {0}", ex)
return False
if not line_split:
return False
try:
# Extract command information
namespace, command = self.get_ns_command(line_split[0])
except ValueError as ex:
# Unknown command
session.write_line(str(ex))
return False
# Get the content of the name space
space = self._commands.get(namespace, None)
if not space:
session.write_line("Unknown name space {0}", namespace)
return False
# Get the method object
method = space.get(command, None)
if method is None:
session.write_line("Unknown command: {0}.{1}", namespace, command)
return False
# Make arguments and keyword arguments
args, kwargs = _make_args(
line_split[1:], session, self._framework.get_properties()
)
try:
# Execute it
result = method(session, *args, **kwargs)
# Store the result as $?
if result is not None:
| python | {
"resource": ""
} |
q9548 | Shell.__extract_help | train | def __extract_help(method):
"""
Formats the help string for the given method
:param method: The method to document
:return: A tuple: (arguments list, documentation line)
"""
if method is None:
return "(No associated method)"
# Get the arguments
arg_spec = get_method_arguments(method)
# Ignore the session argument
start_arg = 1
# Compute the number of arguments with default value
if arg_spec.defaults is not None:
nb_optional = len(arg_spec.defaults)
# Let the mandatory arguments as they are
args = [
"<{0}>".format(arg)
for arg in arg_spec.args[start_arg:-nb_optional]
]
# Add the other arguments
for name, value in zip(
arg_spec.args[-nb_optional:], arg_spec.defaults[-nb_optional:]
):
if value is not None:
| python | {
"resource": ""
} |
q9549 | Shell.__print_command_help | train | def __print_command_help(self, session, namespace, cmd_name):
"""
Prints the documentation of the given command
:param session: Session handler
:param namespace: Name space of the command
:param cmd_name: Name of the command
| python | {
"resource": ""
} |
q9550 | Shell.__print_namespace_help | train | def __print_namespace_help(self, session, namespace, cmd_name=None):
"""
Prints the documentation of all the commands in the given name space,
or only of the given command
:param session: Session Handler
:param namespace: Name space of the command
:param cmd_name: Name of the command to show, None to show them all
"""
session.write_line("=== Name space '{0}' ===", namespace)
# Get all commands in this name space
if cmd_name is None:
names = [command for command in self._commands[namespace]]
| python | {
"resource": ""
} |
q9551 | Shell.print_help | train | def print_help(self, session, command=None):
"""
Prints the available methods and their documentation, or the
documentation of the given command.
"""
if command:
# Single command mode
if command in self._commands:
# Argument is a name space
self.__print_namespace_help(session, command)
was_namespace = True
else:
was_namespace = False
# Also print the name of matching commands
try:
# Extract command name space and name
possibilities = self.get_ns_commands(command)
except ValueError as ex:
# Unknown command
if not | python | {
"resource": ""
} |
q9552 | Shell.var_unset | train | def var_unset(session, name):
"""
Unsets the given variable
"""
name = name.strip()
try:
session.unset(name)
| python | {
"resource": ""
} |
q9553 | _Configuration.add_properties | train | def add_properties(self, properties):
"""
Updates the framework properties dictionary
:param properties: New framework properties to add
| python | {
"resource": ""
} |
q9554 | _Configuration.add_environment | train | def add_environment(self, environ):
"""
Updates the environment dictionary with the given one.
Existing entries are overridden by the given ones
:param environ: | python | {
"resource": ""
} |
q9555 | _Configuration.add_paths | train | def add_paths(self, paths):
"""
Adds entries to the Python path.
The given paths are normalized before being added to the left of the
list
:param paths: New paths to add
| python | {
"resource": ""
} |
q9556 | _Configuration.add_components | train | def add_components(self, components):
"""
Adds a list of components to instantiate
:param components: The description of components
:raise KeyError: Missing component configuration
"""
if components:
for component in | python | {
"resource": ""
} |
q9557 | _Configuration.normalize | train | def normalize(self):
"""
Normalizes environment variables, paths and filters the lists of
bundles to install and start.
After this call, the environment variables of this process will have
been updated.
"""
# Add environment variables
os.environ.update(self._environment)
# Normalize paths and avoid duplicates
self._paths = remove_duplicates( | python | {
"resource": ""
} |
q9558 | InitFileHandler.find_default | train | def find_default(self, filename):
"""
A generate which looks in common folders for the default configuration
file. The paths goes from system defaults to user specific files.
:param filename: The name of the file to find
| python | {
"resource": ""
} |
q9559 | InitFileHandler.load | train | def load(self, filename=None):
"""
Loads the given file and adds its content to the current state.
This method can be called multiple times to merge different files.
If no filename is given, this method loads all default files found.
It returns False if no default configuration file has been found
:param filename: The file to load
:return: True if the file has been correctly parsed, False if no file
was given and no default file exist
:raise | python | {
"resource": ""
} |
q9560 | InitFileHandler.__parse | train | def __parse(self, configuration):
"""
Parses the given configuration dictionary
:param configuration: A configuration as a dictionary (JSON object)
"""
for entry in (
"properties",
"environment",
"paths",
"bundles",
"components",
):
# Check if current values must be reset
reset_key = "reset_{0}".format(entry)
| python | {
"resource": ""
} |
q9561 | InitFileHandler.normalize | train | def normalize(self):
"""
Normalizes environment variables and the Python path.
This method first updates the environment variables (``os.environ``).
Then, it normalizes the Python path (``sys.path``) by resolving all
references to the user directory and environment variables.
| python | {
"resource": ""
} |
q9562 | InitFileHandler.instantiate_components | train | def instantiate_components(self, context):
"""
Instantiate the defined components
.. note::
This method requires the iPOPO core service to be registered.
This means that the ``pelix.ipopo.core`` must have been declared in
the list of bundles (or installed and started programmatically).
:param context: A :class:`~pelix.framework.BundleContext` object
:raise BundleException: Error looking for the iPOPO service or | python | {
"resource": ""
} |
q9563 | literalize_string | train | def literalize_string(content, is_unicode=False):
r'''Literalize a string content.
Examples:
>>> print literalize_string('str')
'str'
>>> print literalize_string('\'str\'')
"'str'"
>>> print literalize_string('\"\'str\'\"')
'"\'str\'"'
'''
quote_mark = "'"
if "'" in content:
quote_mark = | python | {
"resource": ""
} |
q9564 | unescape_string_literal | train | def unescape_string_literal(literal, encoding):
r'''Unescape a string or unicode literal.
Examples:
>>> u = u'\u4e16\u754c\u4f60\u597d' # 世界你好
>>> print unescape_string_literal(repr(u), 'utf-8')
u'世界你好'
>>> print unescape_string_literal(repr(u.encode('utf-8')), 'utf-8')
'世界你好'
>>> print unescape_string_literal(repr(u.encode('big5')), 'utf-8')
'\xa5@\xac\xc9\xa7A\xa6n'
'''
if encoding is None:
encoding = getfilesystemencoding()
if literal[0] in 'uU':
return literalize_string(
literal[2:-1].decode('unicode-escape').encode(encoding),
| python | {
"resource": ""
} |
q9565 | unescape | train | def unescape(b, encoding):
'''Unescape all string and unicode literals in bytes.'''
| python | {
"resource": ""
} |
q9566 | make_unistream | train | def make_unistream(stream):
'''Make a stream which unescapes string literals before writes out.'''
unistream = lambda: 'I am an unistream!'
# make unistream look like the stream
for attr_name in dir(stream):
if not attr_name.startswith('_'):
setattr(unistream, attr_name, getattr(stream, attr_name))
# modify the write method to unescape the output
unistream.write = | python | {
"resource": ""
} |
q9567 | format_frame_info | train | def format_frame_info(frame):
"""
Formats the given stack frame to show its position in the code and
part of its context
:param frame: A stack frame
"""
# Same as in traceback.extract_stack
line_no = frame.f_lineno
code = frame.f_code
filename = code.co_filename
method_name = code.co_name
linecache.checkcache(filename)
try:
# Try to get the type of the calling object
instance = frame.f_locals["self"]
method_name = "{0}::{1}".format(type(instance).__name__, method_name)
except KeyError:
# Not called from a bound method
pass
# File & line
output_lines = [
' File "{0}", line {1}, in {2}'.format(filename, line_no, method_name)
]
# Arguments
if frame.f_locals:
# Pypy keeps f_locals as an empty dictionary
arg_info = inspect.getargvalues(frame)
| python | {
"resource": ""
} |
q9568 | _extract_lines | train | def _extract_lines(filename, f_globals, line_no, around):
"""
Extracts a block of lines from the given file
:param filename: Name of the source file
:param f_globals: Globals of the frame of the current code
:param line_no: Current line of code
:param around: Number of line to print before and after the current one
"""
current_line = linecache.getline(filename, line_no, f_globals)
if not current_line:
# No data on this line
return ""
lines = []
# Add some lines before
for pre_line_no in range(line_no - around, line_no):
pre_line = linecache.getline(filename, pre_line_no, f_globals)
lines.append("{0}".format(pre_line.rstrip()))
# The line itself
lines.append("{0}".format(current_line.rstrip()))
# Add some lines after
for pre_line_no in range(line_no + 1, line_no + around + 1):
pre_line = linecache.getline(filename, pre_line_no, f_globals)
lines.append("{0}".format(pre_line.rstrip()))
| python | {
"resource": ""
} |
q9569 | _ReportCommands.get_level_methods | train | def get_level_methods(self, level):
"""
Returns the methods to call for the given level of report
:param level: The level of report
:return: The set of methods to call to fill the report
:raise KeyError: Unknown level or alias
"""
try:
# Real name of the level
return set(self.__levels[level])
except KeyError:
| python | {
"resource": ""
} |
q9570 | _ReportCommands.print_levels | train | def print_levels(self, session):
"""
Lists available levels
"""
lines = []
for level in sorted(self.get_levels()):
methods = sorted(
method.__name__ for method in self.get_level_methods(level)
) | python | {
"resource": ""
} |
q9571 | _ReportCommands.os_details | train | def os_details():
"""
Returns a dictionary containing details about the operating system
"""
# Compute architecture and linkage
bits, linkage = platform.architecture()
results = {
# Machine details
"platform.arch.bits": bits,
"platform.arch.linkage": linkage,
"platform.machine": platform.machine(),
"platform.process": platform.processor(),
"sys.byteorder": sys.byteorder,
# OS details
"os.name": os.name,
"host.name": socket.gethostname(),
"sys.platform": sys.platform,
"platform.system": platform.system(),
"platform.release": platform.release(),
"platform.version": platform.version(),
"encoding.filesystem": sys.getfilesystemencoding(),
| python | {
"resource": ""
} |
q9572 | _ReportCommands.process_details | train | def process_details():
"""
Returns details about the current process
"""
results = {"argv": sys.argv, "working.directory": os.getcwd()}
# Process ID and execution IDs (UID, GID, Login, ...)
for key, method in {
"pid": "getpid",
"ppid": "getppid",
"login": "getlogin",
"uid": "getuid",
"euid": "geteuid",
"gid": "getgid",
| python | {
"resource": ""
} |
q9573 | _ReportCommands.network_details | train | def network_details():
"""
Returns details about the network links
"""
# Get IPv4 details
ipv4_addresses = [
info[4][0]
for info in socket.getaddrinfo(
socket.gethostname(), None, socket.AF_INET
)
]
# Add localhost
ipv4_addresses.extend(
info[4][0]
for info in socket.getaddrinfo("localhost", None, socket.AF_INET)
)
# Filter addresses
ipv4_addresses = sorted(set(ipv4_addresses))
try:
# Get IPv6 details
ipv6_addresses = [
info[4][0]
for info in socket.getaddrinfo(
socket.gethostname(), None, socket.AF_INET6
)
]
# Add localhost
ipv6_addresses.extend(
| python | {
"resource": ""
} |
q9574 | _ReportCommands.python_details | train | def python_details():
"""
Returns a dictionary containing details about the Python interpreter
"""
build_no, build_date = platform.python_build()
results = {
# Version of interpreter
"build.number": build_no,
"build.date": build_date,
"compiler": platform.python_compiler(),
"branch": platform.python_branch(),
"revision": platform.python_revision(),
"implementation": platform.python_implementation(),
"version": ".".join(str(v) for v in sys.version_info),
# API version
"api.version": sys.api_version,
# Installation details
"prefix": sys.prefix,
"base_prefix": getattr(sys, "base_prefix", None),
"exec_prefix": sys.exec_prefix,
"base_exec_prefix": getattr(sys, "base_exec_prefix", None),
# Execution details
"executable": sys.executable,
"encoding.default": sys.getdefaultencoding(),
# Other details, ...
| python | {
"resource": ""
} |
q9575 | _ReportCommands.python_modules | train | def python_modules():
"""
Returns the list of Python modules and their file
"""
imported = {}
results = {"builtins": sys.builtin_module_names, "imported": imported}
for module_name, module_ in sys.modules.items():
if module_name not in sys.builtin_module_names:
try:
imported[module_name] = inspect.getfile(module_)
| python | {
"resource": ""
} |
q9576 | _ReportCommands.pelix_infos | train | def pelix_infos(self):
"""
Basic information about the Pelix framework instance
"""
framework = self.__context.get_framework()
return {
| python | {
"resource": ""
} |
q9577 | _ReportCommands.pelix_bundles | train | def pelix_bundles(self):
"""
List of installed bundles
"""
framework = self.__context.get_framework()
return {
bundle.get_bundle_id(): {
"name": bundle.get_symbolic_name(),
"version": | python | {
"resource": ""
} |
q9578 | _ReportCommands.pelix_services | train | def pelix_services(self):
"""
List of registered services
"""
return {
svc_ref.get_property(pelix.constants.SERVICE_ID): {
"specifications": svc_ref.get_property(
pelix.constants.OBJECTCLASS
),
"ranking": svc_ref.get_property(
pelix.constants.SERVICE_RANKING
),
| python | {
"resource": ""
} |
q9579 | _ReportCommands.ipopo_factories | train | def ipopo_factories(self):
"""
List of iPOPO factories
"""
try:
with use_ipopo(self.__context) as ipopo:
return {
name: ipopo.get_factory_details(name)
| python | {
"resource": ""
} |
q9580 | _ReportCommands.ipopo_instances | train | def ipopo_instances(self):
"""
List of iPOPO instances
"""
try:
with use_ipopo(self.__context) as ipopo:
return {
instance[0]: ipopo.get_instance_details(instance[0])
| python | {
"resource": ""
} |
q9581 | _ReportCommands.to_json | train | def to_json(self, data):
"""
Converts the given object to a pretty-formatted JSON string
:param data: the object to convert to JSON
:return: A pretty-formatted JSON string
"""
# Don't forget the empty line at the end of the file
return (
json.dumps(
data,
| python | {
"resource": ""
} |
q9582 | _ReportCommands.show_report | train | def show_report(self, session, *levels):
"""
Shows the report that has been generated
"""
if levels:
self.make_report(session, *levels)
if self.__report:
| python | {
"resource": ""
} |
q9583 | _ReportCommands.write_report | train | def write_report(self, session, filename):
"""
Writes the report in JSON format to the given file
"""
if not self.__report:
session.write_line("No report to write down")
return
try:
| python | {
"resource": ""
} |
q9584 | _MqttCallableProxy.handle_result | train | def handle_result(self, result, error):
"""
The result has been received
:param result: Call result
:param error: Error message
"""
if not self._error and not self._result:
# | python | {
"resource": ""
} |
q9585 | main | train | def main():
"""
Starts a Pelix framework and waits for it to stop
"""
# Prepare the framework, with iPOPO and the shell console
# Warning: we only use the first argument of this method, a list of bundles
framework = pelix.framework.create_framework((
# iPOPO
"pelix.ipopo.core",
# Shell core (engine)
"pelix.shell.core",
# Text console
"pelix.shell.console"))
# Start the framework, and the pre-installed bundles
framework.start()
# Get the bundle context of the framework, i.e. the link between the
# framework starter and its content.
context = framework.get_bundle_context()
# Start the spell dictionary bundles, which provide the dictionary services
context.install_bundle("spell_dictionary_EN").start()
context.install_bundle("spell_dictionary_FR").start()
# Start the spell checker bundle, which provides the spell checker service.
context.install_bundle("spell_checker").start()
# Sample usage of the spell checker service
# 1. get its service reference, that describes the service itself
ref_config = context.get_service_reference("spell_checker_service")
# 2. the use_service method allows | python | {
"resource": ""
} |
q9586 | wrap_socket | train | def wrap_socket(socket, certfile, keyfile, password=None):
"""
Wraps an existing TCP socket and returns an SSLSocket object
:param socket: The socket to wrap
:param certfile: The server certificate file
:param keyfile: The server private key file
:param password: Password for the private key file (Python >= 3.3)
:return: The wrapped socket
:raise SSLError: Error wrapping the socket / loading the certificate
:raise OSError: A password has been given, but ciphered key files are not
supported by the current version of Python
"""
# Log warnings when some
logger = logging.getLogger("ssl_wrap")
def _password_support_error():
"""
Logs a warning and raises an OSError if a password has been given but
Python doesn't support ciphered key files.
:raise OSError: If a password has been given
"""
if password:
logger.error(
"The ssl.wrap_socket() fallback method doesn't "
"support key files with a password."
)
raise OSError(
"Can't decode the SSL key file: "
"this version of Python doesn't support it"
)
try:
# Prefer the default context factory, as it will be updated to reflect
# security issues (Python >= 2.7.9 and >= 3.4)
default_context = ssl.create_default_context()
except AttributeError:
default_context = None
try:
# Try to equivalent to create_default_context() in Python 3.5
# Create an SSL context and set its options
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
if default_context is not None:
# Copy options
context.options = default_context.options
else:
# Set up the context as create_default_context() does in Python 3.5
# SSLv2 considered harmful
# SSLv3 has problematic security
context.options |= ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3
# disallow ciphers with known vulnerabilities
context.set_ciphers(_RESTRICTED_SERVER_CIPHERS)
try:
# Load the certificate, with a password
| python | {
"resource": ""
} |
q9587 | make_html_list | train | def make_html_list(items, tag="ul"):
# type: (Iterable[Any], str) -> str
"""
Makes a HTML list from the given iterable
:param items: The items to list
:param tag: The tag to use (ul or ol)
:return: The HTML list code
"""
html_list = "\n".join(
| python | {
"resource": ""
} |
q9588 | AbstractHTTPServletRequest.read_data | train | def read_data(self):
# type: () -> ByteString
"""
Reads all the data in the input stream
:return: The read data
"""
try:
size = int(self.get_header("content-length"))
| python | {
"resource": ""
} |
q9589 | AbstractHTTPServletResponse.send_content | train | def send_content(
self,
http_code,
content,
mime_type="text/html",
http_message=None,
content_length=-1,
):
# type: (int, str, str, str, int) -> None
"""
Utility method to send the given content as an answer.
You can still use get_wfile or write afterwards, if you forced the
content length.
If content_length is negative (default), it will be computed as the
length of the content;
if it is positive, the given value will be used;
if it is None, the content-length header won't be sent.
:param http_code: HTTP result code
:param content: Data to be sent (must be a string)
:param mime_type: Content MIME type (content-type)
:param http_message: HTTP code description
:param content_length: Forced content length
| python | {
"resource": ""
} |
q9590 | make_mreq | train | def make_mreq(family, address):
"""
Makes a mreq structure object for the given address and socket family.
:param family: A socket family (AF_INET or AF_INET6)
:param address: A multicast address (group)
:raise ValueError: Invalid family or address
"""
if not address:
raise ValueError("Empty address")
# Convert the address to a binary form
group_bin = pton(family, address)
if family == socket.AF_INET:
# IPv4
# struct ip_mreq
# {
# struct in_addr imr_multiaddr; /* IP multicast address of group */
# struct in_addr imr_interface; /* local IP address of interface */
| python | {
"resource": ""
} |
q9591 | create_multicast_socket | train | def create_multicast_socket(address, port):
"""
Creates a multicast socket according to the given address and port.
Handles both IPv4 and IPv6 addresses.
:param address: Multicast address/group
:param port: Socket port
:return: A tuple (socket, listening address)
:raise ValueError: Invalid address or port
"""
# Get the information about a datagram (UDP) socket, of any family
try:
addrs_info = socket.getaddrinfo(
address, port, socket.AF_UNSPEC, socket.SOCK_DGRAM
)
except socket.gaierror:
raise ValueError(
"Error retrieving address informations ({0}, {1})".format(
address, port
)
)
if len(addrs_info) > 1:
_logger.debug(
"More than one address information found. Using the first one."
)
# Get the first entry : (family, socktype, proto, canonname, sockaddr)
addr_info = addrs_info[0]
# Only accept IPv4/v6 addresses
if addr_info[0] not in (socket.AF_INET, socket.AF_INET6):
# Unhandled address family
raise ValueError("Unhandled socket family : %d" % (addr_info[0]))
# Prepare the socket
sock = socket.socket(addr_info[0], socket.SOCK_DGRAM, socket.IPPROTO_UDP)
# Reuse address
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if hasattr(socket, "SO_REUSEPORT"):
# Special for MacOS
# pylint: disable=E1101
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
# Bind the socket
if sock.family == socket.AF_INET:
# IPv4 binding
| python | {
"resource": ""
} |
q9592 | close_multicast_socket | train | def close_multicast_socket(sock, address):
"""
Cleans up the given multicast socket.
Unregisters it of the multicast group.
Parameters should be the result of create_multicast_socket
:param sock: A multicast socket
:param address: The multicast address used by the socket
"""
if sock is None:
return
if address:
# Prepare the mreq structure to join the group
mreq = make_mreq(sock.family, address)
# Quit group
if sock.family == socket.AF_INET:
| python | {
"resource": ""
} |
q9593 | HelloImpl.sayHello | train | def sayHello(self, name="Not given", message="nothing"):
"""
Synchronous implementation of IHello.sayHello synchronous method.
The remote calling thread will be blocked until this is executed and
responds.
"""
print(
| python | {
"resource": ""
} |
q9594 | HelloImpl.sayHelloPromise | train | def sayHelloPromise(self, name="Not given", message="nothing"):
"""
Implementation of IHello.sayHelloPromise.
This method will be executed via some thread, and the remote caller
will not block.
"""
print(
| python | {
"resource": ""
} |
q9595 | _set_factory_context | train | def _set_factory_context(factory_class, bundle_context):
# type: (type, Optional[BundleContext]) -> Optional[FactoryContext]
"""
Transforms the context data dictionary into its FactoryContext object form.
:param factory_class: A manipulated class
:param bundle_context: The class bundle context
:return: The factory context, None on error | python | {
"resource": ""
} |
q9596 | _IPopoService.__find_handler_factories | train | def __find_handler_factories(self):
"""
Finds all registered handler factories and stores them
"""
# Get the references
svc_refs = self.__context.get_all_service_references(
| python | {
"resource": ""
} |
q9597 | _IPopoService.__add_handler_factory | train | def __add_handler_factory(self, svc_ref):
# type: (ServiceReference) -> None
"""
Stores a new handler factory
:param svc_ref: ServiceReference of the new handler factory
"""
with self.__handlers_lock:
# Get the handler ID
handler_id = svc_ref.get_property(handlers_const.PROP_HANDLER_ID)
if handler_id in self._handlers:
# Duplicated ID
_logger.warning("Already registered handler ID: %s", handler_id)
else:
# Store the service
self._handlers_refs.add(svc_ref)
self._handlers[handler_id] = self.__context.get_service(svc_ref)
# Try to instantiate waiting components
succeeded = set()
for (
| python | {
"resource": ""
} |
q9598 | _IPopoService.__remove_handler_factory | train | def __remove_handler_factory(self, svc_ref):
# type: (ServiceReference) -> None
"""
Removes an handler factory
:param svc_ref: ServiceReference of the handler factory to remove
"""
with self.__handlers_lock:
# Get the handler ID
handler_id = svc_ref.get_property(handlers_const.PROP_HANDLER_ID)
# Check if this is the handler we use
if svc_ref not in self._handlers_refs:
return
# Clean up
self.__context.unget_service(svc_ref)
self._handlers_refs.remove(svc_ref)
del self._handlers[handler_id]
# List the components using this handler
to_stop = set() # type: Set[StoredInstance]
for factory_name in self.__factories:
_, factory_context = self.__get_factory_with_context(
factory_name
)
if handler_id in factory_context.get_handlers_ids():
to_stop.update(self.__get_stored_instances(factory_name))
with self.__instances_lock:
for stored_instance in to_stop:
| python | {
"resource": ""
} |
q9599 | _IPopoService.__get_factory_with_context | train | def __get_factory_with_context(self, factory_name):
# type: (str) -> Tuple[type, FactoryContext]
"""
Retrieves the factory registered with the given and its factory context
:param factory_name: The name of the factory
:return: A (factory, context) tuple
:raise TypeError: Unknown factory, or factory not manipulated
"""
factory = self.__factories.get(factory_name)
if factory is None:
raise TypeError("Unknown factory '{0}'".format(factory_name))
# Get the factory context
factory_context | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.