code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
# type: (int, str, str, str, int) -> None
self.set_response(http_code, http_message)
if mime_type and not self.is_header_set("content-type"):
self.set_header("content-type", mime_type)
# Convert the content
raw_content = to_bytes(content)
if content... | def send_content(
self,
http_code,
content,
mime_type="text/html",
http_message=None,
content_length=-1,
) | 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;
... | 2.456374 | 2.798925 | 0.877614 |
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 */
... | 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 | 3.957461 | 4.085239 | 0.968722 |
# 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})".form... | 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 | 2.325845 | 2.3256 | 1.000105 |
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:
# IPv4
sock.setsockopt(socket.IPPROTO_IP, socket.IP_DROP_MEMBERSHIP, mre... | 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 | 3.0031 | 3.36866 | 0.891482 |
print(
"Python.sayHello called by: {0} "
"with message: '{1}'".format(name, message)
)
return (
"PythonSync says: Howdy {0} "
"that's a nice runtime you got there".format(name)
) | 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. | 10.437175 | 10.414569 | 1.002171 |
print(
"Python.sayHelloAsync called by: {0} "
"with message: '{1}'".format(name, message)
)
return (
"PythonAsync says: Howdy {0} "
"that's a nice runtime you got there".format(name)
) | def sayHelloAsync(self, name="Not given", message="nothing") | Implementation of IHello.sayHelloAsync.
This method will be executed via some thread, and the remote caller
will not block.
This method should return either a String result (since the return type
of IHello.sayHelloAsync is CompletableFuture<String>, OR a Future that
returns a pyt... | 8.958086 | 9.352591 | 0.957819 |
print(
"Python.sayHelloPromise called by: {0} "
"with message: '{1}'".format(name, message)
)
return (
"PythonPromise says: Howdy {0} "
"that's a nice runtime you got there".format(name)
) | 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. | 9.302206 | 9.551882 | 0.973861 |
# type: (type, Optional[BundleContext]) -> Optional[FactoryContext]
try:
# Try to get the factory context (built using decorators)
context = getattr(factory_class, constants.IPOPO_FACTORY_CONTEXT)
except AttributeError:
# The class has not been manipulated, or too badly
... | def _set_factory_context(factory_class, bundle_context) | 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 | 6.557156 | 6.854574 | 0.95661 |
# type: (Bundle) -> List[Tuple[FactoryContext, type]]
result = []
# Get the Python module
module_ = bundle.get_module()
# Get the bundle context
bundle_context = bundle.get_bundle_context()
for name in dir(module_):
try:
# Get the module member
factory... | def _load_bundle_factories(bundle) | Retrieves a list of pairs (FactoryContext, factory class) with all
readable manipulated classes found in the bundle.
:param bundle: A Bundle object
:return: The list of factories loaded from the bundle | 3.583949 | 3.705598 | 0.967171 |
# Get the references
svc_refs = self.__context.get_all_service_references(
handlers_const.SERVICE_IPOPO_HANDLER_FACTORY
)
if svc_refs:
for svc_ref in svc_refs:
# Store each handler factory
self.__add_handler_factory(svc_ref... | def __find_handler_factories(self) | Finds all registered handler factories and stores them | 5.689708 | 5.425992 | 1.048602 |
# type: (ServiceReference) -> None
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 regi... | def __add_handler_factory(self, svc_ref) | Stores a new handler factory
:param svc_ref: ServiceReference of the new handler factory | 3.738937 | 3.998442 | 0.935098 |
# type: (ServiceReference) -> None
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:
retu... | def __remove_handler_factory(self, svc_ref) | Removes an handler factory
:param svc_ref: ServiceReference of the handler factory to remove | 3.440784 | 3.530779 | 0.974511 |
# type: (str) -> Tuple[type, FactoryContext]
factory = self.__factories.get(factory_name)
if factory is None:
raise TypeError("Unknown factory '{0}'".format(factory_name))
# Get the factory context
factory_context = getattr(
factory, constants.IP... | def __get_factory_with_context(self, factory_name) | 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 | 3.055065 | 3.21034 | 0.951633 |
# type: (str) -> List[StoredInstance]
with self.__instances_lock:
return [
stored_instance
for stored_instance in self.__instances.values()
if stored_instance.factory_name == factory_name
] | def __get_stored_instances(self, factory_name) | Retrieves the list of all stored instances objects corresponding to
the given factory name
:param factory_name: A factory name
:return: All components instantiated from the given factory | 2.501078 | 4.385604 | 0.570293 |
# type: (ComponentContext, object) -> bool
with self.__instances_lock:
# Extract information about the component
factory_context = component_context.factory_context
handlers_ids = factory_context.get_handlers_ids()
name = component_context.name
... | def __try_instantiate(self, component_context, instance) | Instantiates a component, if all of its handlers are there. Returns
False if a handler is missing.
:param component_context: A ComponentContext bean
:param instance: The component instance
:return: True if the component has started,
False if a handler is missing | 4.153017 | 4.116281 | 1.008925 |
# type: (Bundle) -> None
with self.__instances_lock:
# Prepare the list of components
store = self.__auto_restart.setdefault(bundle, [])
for stored_instance in self.__instances.values():
# Get the factory name
factory = stored_... | def _autorestart_store_components(self, bundle) | Stores the components of the given bundle with the auto-restart
property
:param bundle: A Bundle object | 5.807434 | 6.49899 | 0.89359 |
# type: (Bundle) -> None
with self.__instances_lock:
instances = self.__auto_restart.get(bundle)
if not instances:
# Nothing to do
return
for factory, name, properties in instances:
try:
# I... | def _autorestart_components(self, bundle) | Restart the components of the given bundle
:param bundle: A Bundle object | 3.8505 | 4.282031 | 0.899223 |
# type: (int, str, Optional[str]) -> None
with self.__listeners_lock:
# Use a copy of the list of listeners
listeners = self.__listeners[:]
for listener in listeners:
try:
listener.handle_ipopo_event(
constants.IPo... | def _fire_ipopo_event(self, kind, factory_name, instance_name=None) | Triggers an iPOPO event
:param kind: Kind of event
:param factory_name: Name of the factory associated to the event
:param instance_name: Name of the component instance associated to the
event | 3.668236 | 4.248752 | 0.863368 |
# type: (dict, dict) -> dict
# Normalize given properties
if properties is None or not isinstance(properties, dict):
properties = {}
# Use framework properties to fill missing ones
framework = self.__context.get_framework()
for property_name in facto... | def _prepare_instance_properties(self, properties, factory_properties) | Prepares the properties of a component instance, based on its
configuration, factory and framework properties
:param properties: Component instance properties
:param factory_properties: Component factory "default" properties
:return: The merged properties | 3.450987 | 4.027989 | 0.856752 |
# type: (Bundle) -> None
# Load the bundle factories
factories = _load_bundle_factories(bundle)
for context, factory_class in factories:
try:
# Register each found factory
self._register_factory(context.name, factory_class, False)
... | def _register_bundle_factories(self, bundle) | Registers all factories found in the given bundle
:param bundle: A bundle | 3.916682 | 4.224867 | 0.927055 |
# type: (str, type, bool) -> None
if not factory_name or not is_string(factory_name):
raise ValueError("A factory name must be a non-empty string")
if not inspect.isclass(factory):
raise TypeError(
"Invalid factory class '{0}'".format(type(factor... | def _register_factory(self, factory_name, factory, override) | Registers a component factory
:param factory_name: The name of the factory
:param factory: The factory class object
:param override: If true, previous factory is overridden, else an
exception is risen if a previous factory with that
name already... | 3.063729 | 3.160053 | 0.969518 |
factories = list(self.__factories.keys())
for factory_name in factories:
self.unregister_factory(factory_name) | def _unregister_all_factories(self) | Unregisters all factories. This method should be called only after the
iPOPO service has been unregistered (that's why it's not locked) | 3.236346 | 3.325368 | 0.973229 |
# type: (Bundle) -> None
with self.__factories_lock:
# Find out which factories must be removed
to_remove = [
factory_name
for factory_name in self.__factories
if self.get_factory_bundle(factory_name) is bundle
... | def _unregister_bundle_factories(self, bundle) | Unregisters all factories of the given bundle
:param bundle: A bundle | 2.844774 | 3.250528 | 0.875173 |
# Running flag down
self.running = False
# Unregister the service listener
self.__context.remove_service_listener(self)
# Clean up handler factories usages
with self.__instances_lock:
for svc_ref in self._handlers_refs:
self.__contex... | def _stop(self) | iPOPO is stopping: clean everything up | 7.059417 | 6.327908 | 1.115601 |
# type: (BundleEvent) -> None
kind = event.get_kind()
bundle = event.get_bundle()
if kind == BundleEvent.STOPPING_PRECLEAN:
# A bundle is gone, remove its factories after the deactivator has
# been called. That way, the deactivator can kill manually star... | def bundle_changed(self, event) | A bundle event has been triggered
:param event: The bundle event | 4.436141 | 4.670364 | 0.949849 |
# type: (ServiceEvent) -> None
# Call sub-methods
kind = event.get_kind()
svc_ref = event.get_service_reference()
if kind == ServiceEvent.REGISTERED:
# Service coming
with self.__instances_lock:
self.__add_handler_factory(svc_ref)... | def service_changed(self, event) | Called when a handler factory service is un/registered | 3.88367 | 3.498863 | 1.109981 |
# type: (str, str, dict) -> Any
# Test parameters
if not factory_name or not is_string(factory_name):
raise ValueError("Invalid factory name")
if not name or not is_string(name):
raise ValueError("Invalid component name")
if not self.running:
... | def instantiate(self, factory_name, name, properties=None) | Instantiates a component from the given factory, with the given name
:param factory_name: Name of the component factory
:param name: Name of the instance to be started
:param properties: Initial properties of the component instance
:return: The component instance
:raise TypeErro... | 3.441111 | 3.529793 | 0.974876 |
# type: (str, dict) -> int
with self.__instances_lock:
try:
stored_instance = self.__instances[name]
except KeyError:
raise ValueError(
"Unknown component instance '{0}'".format(name)
)
else:... | def retry_erroneous(self, name, properties_update=None) | Removes the ERRONEOUS state of the given component, and retries a
validation
:param name: Name of the component to retry
:param properties_update: A dictionary to update the initial properties
of the component
:return: The new state of the component
... | 3.612079 | 4.596103 | 0.7859 |
# type: (str) -> None
with self.__instances_lock:
try:
stored_instance = self.__instances[name]
except KeyError:
raise ValueError(
"Unknown component instance '{0}'".format(name)
)
else:
... | def invalidate(self, name) | Invalidates the given component
:param name: Name of the component to invalidate
:raise ValueError: Invalid component name | 5.364851 | 6.403384 | 0.837815 |
# type: (str) -> None
if not name:
raise ValueError("Name can't be None or empty")
with self.__instances_lock:
try:
# Running instance
stored_instance = self.__instances.pop(name)
# Store the reference to the fact... | def kill(self, name) | Kills the given component
:param name: Name of the component to kill
:raise ValueError: Invalid component name | 4.555956 | 4.640322 | 0.981819 |
# type: (BundleContext, type) -> bool
if factory is None or bundle_context is None:
# Invalid parameter, to nothing
raise ValueError("Invalid parameter")
context = _set_factory_context(factory, bundle_context)
if not context:
raise TypeError(... | def register_factory(self, bundle_context, factory) | Registers a manually created factory, using decorators programmatically
:param bundle_context: The factory bundle context
:param factory: A manipulated class
:return: True if the factory has been registered
:raise ValueError: Invalid parameter, or factory already registered
:rai... | 7.301605 | 6.376735 | 1.145038 |
# type: (str) -> bool
if not factory_name or not is_string(factory_name):
# Invalid name
return False
with self.__factories_lock:
try:
# Remove the factory from the registry
factory_class = self.__factories.pop(factory... | def unregister_factory(self, factory_name) | Unregisters the given component factory
:param factory_name: Name of the factory to unregister
:return: True the factory has been removed, False if the factory is
unknown | 5.823704 | 5.840294 | 0.997159 |
# type: () -> List[Tuple[str, str, int]]
with self.__instances_lock:
return sorted(
(name, stored_instance.factory_name, stored_instance.state)
for name, stored_instance in self.__instances.items()
) | def get_instances(self) | Retrieves the list of the currently registered component instances
:return: A list of (name, factory name, state) tuples. | 4.612134 | 4.122672 | 1.118725 |
# type: () -> List[Tuple[str, str, Set[str]]]
with self.__instances_lock:
result = []
for name, (context, _) in self.__waiting_handlers.items():
# Compute missing handlers
missing = set(context.factory_context.get_handlers_ids())
... | def get_waiting_components(self) | Returns the list of the instances waiting for their handlers
:return: A list of (name, factory name, missing handlers) tuples | 4.973871 | 4.173401 | 1.191803 |
# type: (str) -> Dict[str, Any]
if not is_string(name):
raise ValueError("Component name must be a string")
with self.__instances_lock:
if name not in self.__instances:
raise ValueError("Unknown component: {0}".format(name))
stored_i... | def get_instance_details(self, name) | Retrieves a snapshot of the given component instance.
The result dictionary has the following keys:
* ``name``: The component name
* ``factory``: The name of the component factory
* ``bundle_id``: The ID of the bundle providing the component factory
* ``state``: The current comp... | 2.866109 | 2.531624 | 1.132123 |
# type: (str) -> Bundle
with self.__factories_lock:
try:
factory = self.__factories[name]
except KeyError:
raise ValueError("Unknown factory '{0}'".format(name))
else:
# Bundle Context is stored in the Factory C... | def get_factory_bundle(self, name) | Retrieves the Pelix Bundle object that registered the given factory
:param name: The name of a factory
:return: The Bundle that registered the given factory
:raise ValueError: Invalid factory | 4.991797 | 5.250251 | 0.950773 |
# type: (str) -> Dict[str, Any]
with self.__factories_lock:
try:
factory = self.__factories[name]
except KeyError:
raise ValueError("Unknown factory '{0}'".format(name))
context = getattr(factory, constants.IPOPO_FACTORY_CONTE... | def get_factory_details(self, name) | Retrieves a dictionary with details about the given factory
* ``name``: The factory name
* ``bundle``: The Bundle object of the bundle providing the factory
* ``properties``: Copy of the components properties defined by the
factory
* ``requirements``: List of the requirements ... | 3.14904 | 2.939842 | 1.07116 |
# type: (socket.socket, bool) -> None
try:
# Use existing value
opt_ipv6_only = socket.IPV6_V6ONLY
except AttributeError:
# Use "known" value
if os.name == "nt":
# Windows: see ws2ipdef.h
opt_ipv6_only = 27
elif platform.system() == "Linux... | def set_double_stack(socket_obj, double_stack=True) | Sets up the IPv6 double stack according to the operating system
:param socket_obj: A socket object
:param double_stack: If True, use the double stack, else only support IPv6
:raise AttributeError: Python or system doesn't support V6
:raise socket.error: Error setting up the double stack value | 5.307607 | 5.550122 | 0.956305 |
# type: (str) -> str
# pylint: disable=C0103
if not ldap_string:
# No content
return ldap_string
# Protect escape character previously in the string
assert is_string(ldap_string)
ldap_string = ldap_string.replace(
ESCAPE_CHARACTER, ESCAPE_CHARACTER + ESCAPE_CHARACTE... | def escape_LDAP(ldap_string) | Escape a string to let it go in an LDAP filter
:param ldap_string: The string to escape
:return: The protected string | 2.691874 | 2.905829 | 0.92637 |
# type: (str) -> str
# pylint: disable=C0103
if ldap_string is None:
return None
if ESCAPE_CHARACTER not in ldap_string:
# No need to loop
return ldap_string
escaped = False
result = ""
for character in ldap_string:
if not escaped and character == ESCA... | def unescape_LDAP(ldap_string) | Unespaces an LDAP string
:param ldap_string: The string to unescape
:return: The unprotected string | 3.23255 | 3.690176 | 0.875988 |
# The filter value is a joker : simple presence test
if tested_value is None:
return False
elif hasattr(tested_value, "__len__"):
# Refuse empty values
# pylint: disable=C1801
return len(tested_value) != 0
# Presence validated
return True | def _comparator_presence(_, tested_value) | Tests a filter which simply a joker, i.e. a value presence test | 8.865952 | 7.021672 | 1.262655 |
if isinstance(tested_value, ITERABLES):
for value in tested_value:
if _star_comparison(filter_value, value):
return True
return False
return _star_comparison(filter_value, tested_value) | def _comparator_star(filter_value, tested_value) | Tests a filter containing a joker | 3.045857 | 3.097825 | 0.983225 |
if not is_string(tested_value):
# Unhandled value type...
return False
parts = filter_value.split("*")
i = 0
last_part = len(parts) - 1
idx = 0
for part in parts:
# Find the part in the tested value
idx = tested_value.find(part, idx)
if idx == -1:
... | def _star_comparison(filter_value, tested_value) | Tests a filter containing a joker | 3.304603 | 3.317091 | 0.996235 |
if isinstance(tested_value, ITERABLES):
# Convert the list items to strings
for value in tested_value:
# Try with the string conversion
if not is_string(value):
value = repr(value)
if filter_value == value:
# Match !
... | def _comparator_eq(filter_value, tested_value) | Tests if the filter value is equal to the tested value | 4.638264 | 4.597248 | 1.008922 |
lower_filter_value = filter_value.lower()
if is_string(tested_value):
# Lower case comparison
return _comparator_eq(lower_filter_value, tested_value.lower())
elif hasattr(tested_value, "__iter__"):
# Extract a list of strings
new_tested = [
value.lower() fo... | def _comparator_approximate(filter_value, tested_value) | Tests if the filter value is nearly equal to the tested value.
If the tested value is a string or an array of string, it compares their
lower case forms | 3.322306 | 3.174256 | 1.046641 |
lower_filter_value = filter_value.lower()
if is_string(tested_value):
# Lower case comparison
return _comparator_star(lower_filter_value, tested_value.lower())
elif hasattr(tested_value, "__iter__"):
# Extract a list of strings
new_tested = [
value.lower() ... | def _comparator_approximate_star(filter_value, tested_value) | Tests if the filter value, which contains a joker, is nearly equal to the
tested value.
If the tested value is a string or an array of string, it compares their
lower case forms | 3.301852 | 3.161613 | 1.044357 |
if is_string(filter_value):
value_type = type(tested_value)
try:
# Try a conversion
filter_value = value_type(filter_value)
except (TypeError, ValueError):
if value_type is int:
# Integer/float comparison trick
try:
... | def _comparator_lt(filter_value, tested_value) | Tests if the filter value is strictly greater than the tested value
tested_value < filter_value | 3.498955 | 3.508632 | 0.997242 |
# type: (str, int) -> Optional[Callable[[Any, Any], bool]]
part1 = string[idx]
try:
part2 = string[idx + 1]
except IndexError:
# String is too short (no comparison)
return None
if part1 == "=":
# Equality
return _comparator_eq
elif part2 != "=":
... | def _compute_comparator(string, idx) | Tries to compute the LDAP comparator at the given index
Valid operators are :
* = : equality
* <= : less than
* >= : greater than
* ~= : approximate
:param string: A LDAP filter string
:param idx: An index in the given string
:return: The corresponding operator, None if unknown | 2.863128 | 3.006318 | 0.95237 |
# type: (str, int) -> Optional[int]
operator = string[idx]
if operator == "&":
return AND
elif operator == "|":
return OR
elif operator == "!":
return NOT
return None | def _compute_operation(string, idx) | Tries to compute the LDAP operation at the given index
Valid operations are :
* & : AND
* | : OR
* ! : NOT
:param string: A LDAP filter string
:param idx: An index in the given string
:return: The corresponding operator (AND, OR or NOT) | 3.390552 | 4.256287 | 0.796599 |
# type: (str, int) -> int
i = idx
for char in string[idx:]:
if not char.isspace():
return i
i += 1
return -1 | def _skip_spaces(string, idx) | Retrieves the next non-space character after idx index in the given string
:param string: The string to look into
:param idx: The base search index
:return: The next non-space character index, -1 if not found | 3.063141 | 4.370237 | 0.70091 |
# type: (str, int, int) -> LDAPCriteria
comparators = "=<>~"
if startidx < 0:
raise ValueError(
"Invalid string range start={0}, end={1}".format(startidx, endidx)
)
# Get the comparator
escaped = False
idx = startidx
for char in ldap_filter[startidx:endidx]:... | def _parse_ldap_criteria(ldap_filter, startidx=0, endidx=-1) | Parses an LDAP sub filter (criterion)
:param ldap_filter: An LDAP filter string
:param startidx: Sub-filter start index
:param endidx: Sub-filter end index
:return: The LDAP sub-filter
:raise ValueError: Invalid sub-filter | 3.164137 | 3.321936 | 0.952498 |
# type: (str) -> Optional[LDAPFilter]
if ldap_filter is None:
# Nothing to do
return None
assert is_string(ldap_filter)
# Remove surrounding spaces
ldap_filter = ldap_filter.strip()
if not ldap_filter:
# Empty string
return None
escaped = False
fil... | def _parse_ldap(ldap_filter) | Parses the given LDAP filter string
:param ldap_filter: An LDAP filter string
:return: An LDAPFilter object, None if the filter was empty
:raise ValueError: The LDAP filter string is invalid | 3.366084 | 3.424771 | 0.982864 |
# type: (Any) -> Optional[Union[LDAPFilter, LDAPCriteria]]
if ldap_filter is None:
return None
if isinstance(ldap_filter, (LDAPFilter, LDAPCriteria)):
# No conversion needed
return ldap_filter
elif is_string(ldap_filter):
# Parse the filter
return _parse_lda... | def get_ldap_filter(ldap_filter) | Retrieves the LDAP filter object corresponding to the given filter.
Parses it the argument if it is an LDAPFilter instance
:param ldap_filter: An LDAP filter (LDAPFilter or string)
:return: The corresponding filter, can be None
:raise ValueError: Invalid filter string found
:raise TypeError: Unknow... | 3.57695 | 3.963409 | 0.902493 |
# type: (Iterable[Any], int) -> Optional[Union[LDAPFilter, LDAPCriteria]]
if not filters:
return None
if not hasattr(filters, "__iter__") or is_string(filters):
raise TypeError("Filters argument must be iterable")
# Remove None filters and convert others
ldap_filters = []
... | def combine_filters(filters, operator=AND) | Combines two LDAP filters, which can be strings or LDAPFilter objects
:param filters: Filters to combine
:param operator: The operator for combination
:return: The combined filter, can be None if all filters are None
:raise ValueError: Invalid filter string found
:raise TypeError: Unknown filter ty... | 3.209287 | 3.380506 | 0.949351 |
if not isinstance(ldap_filter, (LDAPFilter, LDAPCriteria)):
raise TypeError(
"Invalid filter type: {0}".format(type(ldap_filter).__name__)
)
if len(self.subfilters) >= 1 and self.operator == NOT:
raise ValueError("Not operator only handles on... | def append(self, ldap_filter) | Appends a filter or a criterion to this filter
:param ldap_filter: An LDAP filter or criterion
:raise TypeError: If the parameter is not of a known type
:raise ValueError: If the more than one filter is associated to a
NOT operator | 4.377407 | 3.56479 | 1.227956 |
# Use a generator, and declare it outside of the method call
# => seems to be quite a speed up trick
generator = (
criterion.matches(properties) for criterion in self.subfilters
)
# Extract "if" from loops and use built-in methods
if self.operator ==... | def matches(self, properties) | Tests if the given properties matches this LDAP filter and its children
:param properties: A dictionary of properties
:return: True if the properties matches this filter, else False | 11.531102 | 11.248003 | 1.025169 |
if not self.subfilters:
# No sub-filters
return None
# New sub-filters list
new_filters = []
for subfilter in self.subfilters:
# Normalize the sub-filter before storing it
norm_filter = subfilter.normalize()
if norm_fi... | def normalize(self) | Returns the first meaningful object in this filter. | 4.499586 | 4.161824 | 1.081157 |
try:
# Use the comparator
return self.comparator(self.value, properties[self.name])
except KeyError:
# Criterion key is not in the properties
return False | def matches(self, properties) | Tests if the given criterion matches this LDAP criterion
:param properties: A dictionary of properties
:return: True if the properties matches this criterion, else False | 6.143498 | 5.686286 | 1.080406 |
# Create the framework
framework = pelix.framework.create_framework(
(
"pelix.ipopo.core",
"pelix.ipopo.waiting",
# Shell
"pelix.shell.core",
"pelix.shell.ipopo",
"pelix.shell.console",
# HTTP Service
"p... | def main(is_server, discoveries, transports, http_port, other_arguments) | Runs the framework
:param is_server: If True, starts the provider bundle,
else the consumer one
:param discoveries: List of discovery protocols
:param transports: List of RPC protocols
:param http_port: Port of the HTTP server
:param other_arguments: Other arguments | 3.881514 | 3.782553 | 1.026162 |
# Install the bundle
self.context.install_bundle("pelix.remote.discovery.multicast").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_DISCOVERY_MULTICAST, "pelix-discovery-multicast"
... | def discovery_multicast(self) | Installs the multicast discovery bundles and instantiates components | 10.10816 | 8.745319 | 1.155837 |
# Remove Zeroconf debug output
logging.getLogger("zeroconf").setLevel(logging.WARNING)
# Install the bundle
self.context.install_bundle("pelix.remote.discovery.mdns").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
... | def discovery_mdns(self) | Installs the mDNS discovery bundles and instantiates components | 10.335804 | 9.40064 | 1.099479 |
# Install the bundle
self.context.install_bundle("pelix.remote.discovery.mqtt").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_DISCOVERY_MQTT,
"pelix-discovery-mqtt",
... | def discovery_mqtt(self) | Installs the MQTT discovery bundles and instantiates components | 7.224279 | 6.61404 | 1.092264 |
# Install the bundle
self.context.install_bundle("pelix.remote.discovery.redis").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_DISCOVERY_REDIS,
"pelix-discovery-redis",
... | def discovery_redis(self) | Installs the Redis discovery bundles and instantiates components | 7.173604 | 6.631429 | 1.081758 |
# Install the bundle
self.context.install_bundle("pelix.remote.discovery.zookeeper").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_DISCOVERY_ZOOKEEPER,
"pelix-discovery-zoo... | def discovery_zookeeper(self) | Installs the ZooKeeper discovery bundles and instantiates components | 7.101761 | 6.768317 | 1.049265 |
# Install the bundle
self.context.install_bundle("pelix.remote.json_rpc").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_TRANSPORT_JSONRPC_EXPORTER, "pelix-jsonrpc-exporter"
)
... | def transport_jsonrpc(self) | Installs the JSON-RPC transport bundles and instantiates components | 6.765929 | 6.029908 | 1.122062 |
# Install the bundle
self.context.install_bundle(
"pelix.remote.transport.jabsorb_rpc"
).start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_TRANSPORT_JABSORBRPC_EXPORTER,
... | def transport_jabsorbrpc(self) | Installs the JABSORB-RPC transport bundles and instantiates components | 5.017532 | 4.649197 | 1.079225 |
# Install the bundle
self.context.install_bundle("pelix.remote.transport.mqtt_rpc").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_TRANSPORT_MQTTRPC_EXPORTER,
"pelix-mqttrpc... | def transport_mqttrpc(self) | Installs the MQTT-RPC transport bundles and instantiates components | 3.396782 | 3.151327 | 1.07789 |
# Install the bundle
self.context.install_bundle("pelix.remote.xml_rpc").start()
with use_waiting_list(self.context) as ipopo:
# Instantiate the discovery
ipopo.add(
rs.FACTORY_TRANSPORT_XMLRPC_EXPORTER, "pelix-xmlrpc-exporter"
)
... | def transport_xmlrpc(self) | Installs the XML-RPC transport bundles and instantiates components | 6.510721 | 5.85851 | 1.111327 |
# Extract information from the context
requirements = component_context.get_handler(
ipopo_constants.HANDLER_REQUIRES_BEST
)
requires_filters = component_context.properties.get(
ipopo_constants.IPOPO_REQUIRES_FILTERS, None
)
# Prepare req... | def get_handlers(self, component_context, instance) | Sets up service providers for the given component
:param component_context: The ComponentContext bean
:param instance: The component instance
:return: The list of handlers associated to the given component | 6.977404 | 7.49085 | 0.931457 |
with self._lock:
new_ranking = svc_ref.get_property(SERVICE_RANKING)
if self._current_ranking is not None:
if new_ranking > self._current_ranking:
# New service with better ranking: use it
self._pending_ref = svc_ref
... | def on_service_arrival(self, svc_ref) | Called when a service has been registered in the framework
:param svc_ref: A service reference | 3.911735 | 4.120366 | 0.949366 |
with self._lock:
if svc_ref is self.reference:
# Injected service going away...
service = self._value
# Clear the instance values
self._current_ranking = None
self._value = None
self.reference =... | def on_service_departure(self, svc_ref) | Called when a service has been unregistered from the framework
:param svc_ref: A service reference | 7.390048 | 8.355138 | 0.884491 |
with self._lock:
if self.reference is None:
# A previously registered service now matches our filter
return self.on_service_arrival(svc_ref)
else:
# Check if the ranking changed the service to inject
best_ref = self... | def on_service_modify(self, svc_ref, old_properties) | Called when a service has been modified in the framework
:param svc_ref: A service reference
:param old_properties: Previous properties values | 7.965253 | 8.708078 | 0.914697 |
with self.__lock:
if self.__deleted:
raise ValueError("{0} has been deleted".format(self.__pid))
elif not self.__updated:
# Fresh configuration
return None
# Filter a copy of the properties
props = self.__... | def get_properties(self) | Return the properties of this Configuration object.
The Dictionary object returned is a private copy for the caller and may
be changed without influencing the stored configuration.
If called just after the configuration is created and before update has
been called, this method returns N... | 7.494636 | 5.442587 | 1.377036 |
if not properties:
# Nothing to do
return False
with self.__lock:
# Make a copy of the properties
properties = properties.copy()
# Override properties
properties[services.CONFIG_PROP_PID] = self.__pid
if self... | def __properties_update(self, properties) | Internal update of configuration properties. Does not notifies the
ConfigurationAdmin of this modification.
:param properties: the new set of properties for this configuration
:return: True if the properties have been updated, else False | 5.550307 | 5.055037 | 1.097976 |
# pylint: disable=W0212
with self.__lock:
# Update properties
if self.__properties_update(properties):
# Update configurations, if something changed
self.__config_admin._update(self) | def update(self, properties=None) | If called without properties, only notifies listeners
Update the properties of this Configuration object.
Stores the properties in persistent storage after adding or overwriting
the following properties:
* "service.pid" : is set to be the PID of this configuration.
* "service.f... | 9.88884 | 12.703237 | 0.77845 |
# pylint: disable=W0212
with self.__lock:
if self.__deleted:
# Nothing to do
return
# Update status
self.__deleted = True
# Notify ConfigurationAdmin, notify services only if the
# configuration had be... | def delete(self, directory_updated=False) | Delete this configuration
:param directory_updated: If True, tell ConfigurationAdmin to not
recall the directory of this deletion
(internal use only) | 6.510032 | 5.705095 | 1.141091 |
if not self.is_valid():
# Do not test invalid configurations
return False
return ldap_filter.matches(self.__properties) | def matches(self, ldap_filter) | Tests if this configuration matches the given filter.
:param ldap_filter: A parsed LDAP filter object
:return: True if the properties of this configuration matches the
filter | 10.181251 | 8.763325 | 1.161802 |
if path is None or not os.path.isdir(path):
return
yielded = set()
try:
file_names = os.listdir(path)
except OSError:
# ignore unreadable directories like import does
file_names = []
# handle packages before same-named modules
file_names.sort()
for fil... | def walk_modules(path) | Code from ``pkgutil.ImpImporter.iter_modules()``: walks through a folder
and yields all loadable packages and modules.
:param path: Path where to look for modules
:return: Generator to walk through found packages and modules | 2.498068 | 2.569459 | 0.972216 |
# type: (Union[list, tuple], dict, bool, bool, bool) -> Framework
# Test if a framework already exists
if FrameworkFactory.is_framework_running(None):
raise ValueError("A framework is already running")
# Create the framework
framework = FrameworkFactory.get_framework(properties)
#... | def create_framework(
bundles,
properties=None,
auto_start=False,
wait_for_stop=False,
auto_delete=False,
) | Creates a Pelix framework, installs the given bundles and returns its
instance reference.
If *auto_start* is True, the framework will be started once all bundles
will have been installed
If *wait_for_stop* is True, the method will return only when the framework
will have stopped. This requires *auto... | 2.710657 | 2.691851 | 1.006987 |
# type: (str) -> bool
while path:
if os.path.exists(path):
return True
else:
path = os.path.dirname(path)
return False | def _package_exists(path) | Checks if the given Python path matches a valid file or a valid container
file
:param path: A Python path
:return: True if the module or its container exists | 2.752633 | 4.571786 | 0.602091 |
# Normalize Python paths
whole_path = [
os.path.abspath(path) for path in sys.path if os.path.exists(path)
]
# Keep the "dynamic" current folder indicator and add the "static"
# current path
# Use an OrderedDict to have a faster lookup (path not in whole_set)
whole_set = collec... | def normalize_path() | Normalizes sys.path to avoid the use of relative folders | 5.05367 | 4.869442 | 1.037834 |
# Get the activator
activator = getattr(self.__module, ACTIVATOR, None)
if activator is None:
# Get the old activator
activator = getattr(self.__module, ACTIVATOR_LEGACY, None)
if activator is not None:
# Old activator found: print a d... | def __get_activator_method(self, method_name) | Retrieves the requested method of the activator, or returns None
:param method_name: A method name
:return: A method, or None | 3.869448 | 4.005348 | 0.966071 |
# type: (int) -> None
self.__framework._dispatcher.fire_bundle_event(BundleEvent(kind, self)) | def _fire_bundle_event(self, kind) | Fires a bundle event of the given kind
:param kind: Kind of event | 7.919173 | 13.788973 | 0.574312 |
# type: () -> List[ServiceReference]
if self._state == Bundle.UNINSTALLED:
raise BundleException(
"Can't call 'get_registered_services' on an "
"uninstalled bundle"
)
return self.__framework._registry.get_bundle_registered_services... | def get_registered_services(self) | Returns this bundle's ServiceReference list for all services it has
registered or an empty list
The list is valid at the time of the call to this method, however, as
the Framework is a very dynamic environment, services can be modified
or unregistered at any time.
:return: An a... | 4.911635 | 5.324452 | 0.922468 |
# type: () -> List[ServiceReference]
if self._state == Bundle.UNINSTALLED:
raise BundleException(
"Can't call 'get_services_in_use' on an uninstalled bundle"
)
return self.__framework._registry.get_bundle_imported_services(self) | def get_services_in_use(self) | Returns this bundle's ServiceReference list for all services it is
using or an empty list.
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
the Framework is ... | 5.518563 | 6.10468 | 0.903989 |
# type: () -> str
# Get the version value
version = getattr(self.__module, "__version__", None)
if version:
return version
# Convert the __version_info__ entry
info = getattr(self.__module, "__version_info__", None)
if info:
retur... | def get_version(self) | Retrieves the bundle version, using the ``__version__`` or
``__version_info__`` attributes of its module.
:return: The bundle version, "0.0.0" by default | 3.804128 | 3.940907 | 0.965292 |
if self.__framework._state not in (Bundle.STARTING, Bundle.ACTIVE):
# Framework is not running
raise BundleException(
"Framework must be started before its bundles"
)
with self._lock:
if self._state in (Bundle.ACTIVE, Bundle.START... | def start(self) | Starts the bundle. Does nothing if the bundle is already starting or
active.
:raise BundleException: The framework is not yet started or the bundle
activator failed. | 3.500168 | 3.197721 | 1.094582 |
if self._state != Bundle.ACTIVE:
# Invalid state
return
exception = None
with self._lock:
# Store the bundle current state
previous_state = self._state
# Stopping...
self._state = Bundle.STOPPING
self.... | def stop(self) | Stops the bundle. Does nothing if the bundle is already stopped.
:raise BundleException: The bundle activator failed. | 5.254874 | 4.960503 | 1.059343 |
# Copy the services list, as it will be modified during the process
with self.__registration_lock:
registered_services = self.__registered_services.copy()
for registration in registered_services:
try:
registration.unregister()
except ... | def __unregister_services(self) | Unregisters all bundle services | 4.351806 | 4.098744 | 1.061741 |
with self._lock:
if self._state == Bundle.ACTIVE:
self.stop()
# Change the bundle state
self._state = Bundle.UNINSTALLED
# Call the framework
self.__framework.uninstall_bundle(self) | def uninstall(self) | Uninstalls the bundle | 5.581166 | 4.727951 | 1.180462 |
with self._lock:
# Was it active ?
restart = self._state == Bundle.ACTIVE
# Send the update event
self._fire_bundle_event(BundleEvent.UPDATE_BEGIN)
try:
# Stop the bundle
self.stop()
except:
... | def update(self) | Updates the bundle | 3.231026 | 3.172185 | 1.018549 |
# type: (str, object) -> bool
with self.__properties_lock:
if name in self.__properties:
# Already stored property
return False
self.__properties[name] = value
return True | def add_property(self, name, value) | Adds a property to the framework **if it is not yet set**.
If the property already exists (same name), then nothing is done.
Properties can't be updated.
:param name: The property name
:param value: The value to set
:return: True if the property was stored, else False | 4.002217 | 5.438974 | 0.73584 |
# type: (Optional[str], Optional[str], bool) -> Optional[List[ServiceReference]]
return self._registry.find_service_references(
clazz, ldap_filter, only_one
) | def find_service_references(
self, clazz=None, ldap_filter=None, only_one=False
) | Finds all services references matching the given filter.
:param clazz: Class implemented by the service
:param ldap_filter: Service filter
:param only_one: Return the first matching service reference only
:return: A list of found reference, or None
:raise BundleException: An err... | 2.83659 | 4.918745 | 0.57669 |
# type: (int) -> Union[Bundle, Framework]
if bundle_id == 0:
# "System bundle"
return self
with self.__bundles_lock:
if bundle_id not in self.__bundles:
raise BundleException("Invalid bundle ID {0}".format(bundle_id))
ret... | def get_bundle_by_id(self, bundle_id) | Retrieves the bundle with the given ID
:param bundle_id: ID of an installed bundle
:return: The requested bundle
:raise BundleException: The ID is invalid | 3.96429 | 4.694532 | 0.844448 |
# type: (str) -> Optional[Bundle]
if bundle_name is None:
# Nothing to do
return None
if bundle_name is self.get_symbolic_name():
# System bundle requested
return self
with self.__bundles_lock:
for bundle in self.__bu... | def get_bundle_by_name(self, bundle_name) | Retrieves the bundle with the given name
:param bundle_name: Name of the bundle to look for
:return: The requested bundle, None if not found | 3.552991 | 4.1392 | 0.858376 |
# type: () -> List[Bundle]
with self.__bundles_lock:
return [
self.__bundles[bundle_id]
for bundle_id in sorted(self.__bundles.keys())
] | def get_bundles(self) | Returns the list of all installed bundles
:return: the list of all installed bundles | 3.601777 | 4.882513 | 0.737689 |
# type: (str) -> object
with self.__properties_lock:
return self.__properties.get(name, os.getenv(name)) | def get_property(self, name) | Retrieves a framework or system property. As framework properties don't
change while it's running, this method don't need to be protected.
:param name: The property name | 5.549615 | 8.901443 | 0.623451 |
# type: (Bundle, ServiceReference) -> Any
if not isinstance(bundle, Bundle):
raise TypeError("First argument must be a Bundle object")
elif not isinstance(reference, ServiceReference):
raise TypeError("Second argument must be a ServiceReference object")
... | def get_service(self, bundle, reference) | Retrieves the service corresponding to the given reference
:param bundle: The bundle requiring the service
:param reference: A service reference
:return: The requested service
:raise BundleException: The service could not be found
:raise TypeError: The argument is not a ServiceR... | 3.69065 | 4.263797 | 0.865578 |
# type: (str, str) -> Bundle
with self.__bundles_lock:
# A bundle can't be installed twice
for bundle in self.__bundles.values():
if bundle.get_symbolic_name() == name:
_logger.debug("Already installed bundle: %s", name)
... | def install_bundle(self, name, path=None) | Installs the bundle with the given name
*Note:* Before Pelix 0.5.0, this method returned the ID of the
installed bundle, instead of the Bundle object.
**WARNING:** The behavior of the loading process is subject to changes,
as it does not allow to safely run multiple frameworks in the s... | 3.397734 | 3.31533 | 1.024856 |
# type: (str, bool, str) -> tuple
if not path:
raise ValueError("Empty path")
elif not is_string(path):
raise ValueError("Path must be a string")
# Use an absolute path
path = os.path.abspath(path)
if not os.path.exists(path):
... | def install_package(self, path, recursive=False, prefix=None) | Installs all the modules found in the given package
:param path: Path of the package (folder)
:param recursive: If True, install the sub-packages too
:param prefix: (**internal**) Prefix for all found modules
:return: A 2-tuple, with the list of installed bundles and the list
... | 3.85529 | 3.764667 | 1.024072 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.