Datasets:
bjoernp
/
code_search_net_python_processed_400k

Dataset card Data Studio Files
xet
Community
code
string
signature
string
docstring
string
loss_without_docstring
float64
loss_with_docstring
float64
factor
float64
# type: (Any, ServiceRegistration) -> Any svc_ref = svc_registration.get_reference() service = factory.get_service(self.__bundle, svc_registration) try: # Check if the service already exists services, counter = self.__factored[svc_ref] services.append(service) counter.inc() except KeyError: counter = _UsageCounter() counter.inc() # Store the counter self.__factored[svc_ref] = ([service], counter) return service
def _get_from_prototype(self, factory, svc_registration)
Returns a service instance from a Prototype Service Factory :param factory: The service factory :param svc_registration: The ServiceRegistration object :return: The requested service instance returned by the factory
4.347647
5.571467
0.780342
# type: (Any, ServiceRegistration) -> Any svc_ref = svc_registration.get_reference() if svc_ref.is_prototype(): return self._get_from_prototype(factory, svc_registration) return self._get_from_factory(factory, svc_registration)
def get_service(self, factory, svc_registration)
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 :return: The requested service instance (created if necessary)
3.084963
4.356134
0.708188
# type: (Any, ServiceRegistration, Any) -> bool 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( self.__bundle, svc_registration, service ) if not counter.dec(): # All references have been released: clean up del self.__factored[svc_ref] # Call the factory factory.unget_service(self.__bundle, svc_registration) # No more reference to this service return True # Some references are still there return False
def unget_service(self, factory, svc_registration, service=None)
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
4.864832
4.911957
0.990406
# type: (Any, ServiceRegistration) -> bool 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( self.__bundle, svc_registration, service ) except Exception: # Ignore instance-level exceptions, potential errors # will reappear in unget_service() pass # Call the factory factory.unget_service(self.__bundle, svc_registration) # No more association svc_ref.unused_by(self.__bundle) return True
def cleanup_service(self, factory, svc_registration)
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
6.087673
6.749803
0.901904
if bundle is None or bundle is self.__bundle: # Ignore return with self.__usage_lock: try: if not self.__using_bundles[bundle].dec(): # This bundle has cleaner all of its usages of this # reference del self.__using_bundles[bundle] except KeyError: # Ignore error pass
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
9.534067
9.062369
1.05205
if bundle is None or bundle is self.__bundle: # Ignore return with self.__usage_lock: self.__using_bundles.setdefault(bundle, _UsageCounter()).inc()
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
11.161386
11.833662
0.943189
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] except KeyError: # Service ranking not updated: ignore pass # pylint: disable=W0212 with self.__reference._props_lock: # Update the properties previous = self.__properties.copy() self.__properties.update(properties) if self.__reference.needs_sort_update(): # The sort key and the registry must be updated self.__update_callback(self.__reference) # Trigger a new computation in the framework event = ServiceEvent( ServiceEvent.MODIFIED, self.__reference, previous ) self.__framework._dispatcher.fire_service_event(event)
def set_properties(self, properties)
Updates the service properties :param properties: The new properties :raise TypeError: The argument is not a dictionary
4.601779
4.379099
1.050851
with self.__bnd_lock: self.__bnd_listeners = [] with self.__svc_lock: self.__svc_listeners.clear() with self.__fw_lock: self.__fw_listeners = []
def clear(self)
Clears the event dispatcher
5.454786
5.315942
1.026118
if listener is None or not hasattr(listener, "bundle_changed"): raise BundleException("Invalid bundle listener given") with self.__bnd_lock: if listener in self.__bnd_listeners: self._logger.warning( "Already known bundle listener '%s'", listener ) return False self.__bnd_listeners.append(listener) return True
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
4.118845
3.310116
1.244321
if listener is None or not hasattr(listener, "framework_stopping"): raise BundleException("Invalid framework listener given") with self.__fw_lock: if listener in self.__fw_listeners: self._logger.warning( "Already known framework listener '%s'", listener ) return False self.__fw_listeners.append(listener) return True
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
4.340727
3.398587
1.277215
if listener is None or not hasattr(listener, "service_changed"): raise BundleException("Invalid service listener given") with self.__svc_lock: if listener in self.__listeners_data: self._logger.warning( "Already known service listener '%s'", listener ) return False try: ldap_filter = ldapfilter.get_ldap_filter(ldap_filter) except ValueError as ex: raise BundleException("Invalid service filter: {0}".format(ex)) stored = ListenerInfo( bundle_context, listener, specification, ldap_filter ) self.__listeners_data[listener] = stored self.__svc_listeners.setdefault(specification, []).append(stored) return True
def add_service_listener( self, bundle_context, listener, specification=None, ldap_filter=None )
Registers a service listener :param bundle_context: The bundle_context of the service listener :param listener: The service listener :param specification: The specification that must provide the service (optional, None to accept all services) :param ldap_filter: Filter that must match the service properties (optional, None to accept all services) :return: True if the listener has been registered, False if it was already known :raise BundleException: An invalid listener has been given
3.459681
3.268568
1.05847
with self.__bnd_lock: if listener not in self.__bnd_listeners: return False self.__bnd_listeners.remove(listener) return True
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
3.752072
3.975151
0.943882
with self.__fw_lock: try: self.__fw_listeners.remove(listener) return True except ValueError: return False
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
3.653983
4.012651
0.910616
with self.__svc_lock: try: data = self.__listeners_data.pop(listener) spec_listeners = self.__svc_listeners[data.specification] spec_listeners.remove(data) if not spec_listeners: del self.__svc_listeners[data.specification] return True except KeyError: return False
def remove_service_listener(self, listener)
Unregisters a service listener :param listener: The service listener :return: True if the listener has been unregistered
3.500746
4.124161
0.848838
with self.__bnd_lock: # Copy the list of listeners listeners = self.__bnd_listeners[:] # Call'em all for listener in listeners: try: listener.bundle_changed(event) except: self._logger.exception("Error calling a bundle listener")
def fire_bundle_event(self, event)
Notifies bundle events listeners of a new event in the calling thread. :param event: The bundle event
5.217784
6.936026
0.752273
with self.__fw_lock: # Copy the list of listeners listeners = self.__fw_listeners[:] for listener in listeners: try: listener.framework_stopping() except: self._logger.exception( "An error occurred calling one of the " "framework stop listeners" )
def fire_framework_stopping(self)
Calls all framework listeners, telling them that the framework is stopping
4.443958
3.782756
1.174794
# 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: listeners.update(self.__svc_listeners[spec]) except KeyError: pass # Add those which listen to any specification try: listeners.update(self.__svc_listeners[None]) except KeyError: pass # Filter listeners with EventListenerHooks listeners = self._filter_with_hooks(event, listeners) # Get the listeners for this specification for data in listeners: # Default event to send : the one we received sent_event = event # Test if the service properties matches the filter ldap_filter = data.ldap_filter if ldap_filter is not None and not ldap_filter.matches(properties): # Event doesn't match listener filter... if ( svc_modified and previous is not None and ldap_filter.matches(previous) ): # ... but previous properties did match sent_event = endmatch_event else: # Didn't match before either, ignore it continue # Call'em try: data.listener.service_changed(sent_event) except: self._logger.exception("Error calling a service listener")
def fire_service_event(self, event)
Notifies service events listeners of a new event in the calling thread. :param event: The service event
4.455776
4.646928
0.958865
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, # pass in svc_event and shrinkable_ctx_listeners # (which can be modified by hook) try: hook_svc.event(svc_event, shrinkable_ctx_listeners) except: self._logger.exception( "Error calling EventListenerHook" ) finally: # Clean up the service self._registry.unget_service(hook_bundle, hook_ref) # Convert the shrinkable_ctx_listeners back to a list of listeners # before returning ret_listeners = set() for bnd_listeners in shrinkable_ctx_listeners.values(): ret_listeners.update(bnd_listeners) return ret_listeners # No hook ref return listeners
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
3.590726
3.494478
1.027543
with self.__svc_lock: self.__svc_registry.clear() self.__svc_factories.clear() self.__svc_specs.clear() self.__bundle_svc.clear() self.__bundle_imports.clear() self.__factory_usage.clear() self.__pending_services.clear()
def clear(self)
Clears the registry
5.118087
5.050161
1.01345
with self.__svc_lock: # Prepare properties service_id = self.__next_service_id self.__next_service_id += 1 properties[OBJECTCLASS] = classes properties[SERVICE_ID] = service_id properties[SERVICE_BUNDLEID] = bundle.get_bundle_id() # Compute service scope if prototype: properties[SERVICE_SCOPE] = SCOPE_PROTOTYPE elif factory: properties[SERVICE_SCOPE] = SCOPE_BUNDLE else: properties[SERVICE_SCOPE] = SCOPE_SINGLETON # Force to have a valid service ranking try: properties[SERVICE_RANKING] = int(properties[SERVICE_RANKING]) except (KeyError, ValueError, TypeError): properties[SERVICE_RANKING] = 0 # Make the service reference svc_ref = ServiceReference(bundle, properties) # Make the service registration svc_registration = ServiceRegistration( self.__framework, svc_ref, properties, self.__sort_registry ) # Store service information if prototype or factory: self.__svc_factories[svc_ref] = (svc_instance, svc_registration) # Also store factories, as they must appear like any other service self.__svc_registry[svc_ref] = svc_instance for spec in classes: spec_refs = self.__svc_specs.setdefault(spec, []) bisect.insort_left(spec_refs, svc_ref) # Reverse map, to ease bundle/service association bundle_services = self.__bundle_svc.setdefault(bundle, set()) bundle_services.add(svc_ref) return svc_registration
def register( self, bundle, classes, properties, svc_instance, factory, prototype )
Registers a service. :param bundle: The bundle that registers the service :param classes: The classes implemented by the service :param properties: The properties associated to the service :param svc_instance: The instance of the service :param factory: If True, the given service is a service factory :param prototype: If True, the given service is a prototype service factory (the factory argument is considered True) :return: The ServiceRegistration object
3.377866
3.352557
1.007549
# type: (ServiceReference) -> None 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) spec_refs = self.__svc_specs[spec] idx = bisect.bisect_left(spec_refs, svc_ref) del spec_refs[idx] # ... use the new sort key svc_ref.update_sort_key() for spec in svc_ref.get_property(OBJECTCLASS): # ... and insert it again spec_refs = self.__svc_specs[spec] bisect.insort_left(spec_refs, svc_ref)
def __sort_registry(self, svc_ref)
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
3.497068
3.626325
0.964356
# type: (ServiceReference) -> Any 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: del self.__svc_specs[spec] # Remove the service factory if svc_ref.is_factory(): # Call unget_service for all client bundle factory, svc_reg = self.__svc_factories.pop(svc_ref) for counter in self.__factory_usage.values(): counter.cleanup_service(factory, svc_reg) else: # Delete bundle association bundle_services = self.__bundle_svc[bundle] bundle_services.remove(svc_ref) if not bundle_services: # Don't keep empty lists del self.__bundle_svc[bundle] return service
def unregister(self, svc_ref)
Unregisters a service :param svc_ref: A service reference :return: The unregistered service instance :raise BundleException: Unknown service reference
3.741847
3.843951
0.973438
with self.__svc_lock: try: svc_refs = self.__bundle_svc.pop(bundle) except KeyError: # Nothing to do return set() else: # Clean the registry specs = set() for svc_ref in svc_refs: if svc_ref.is_factory(): continue # Remove direct references self.__pending_services[svc_ref] = self.__svc_registry.pop( svc_ref ) specs.update(svc_ref.get_property(OBJECTCLASS)) # Clean the specifications cache 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: del self.__svc_specs[spec] return svc_refs
def hide_bundle_services(self, bundle)
Hides the services of the given bundle (removes them from lists, but lets them be unregistered) :param bundle: The bundle providing services :return: The references of the hidden services
4.11135
3.970825
1.035389
with self.__svc_lock: if clazz is None and ldap_filter is None: # Return a sorted copy of the keys list # Do not return None, as the whole content was required return sorted(self.__svc_registry.keys()) if hasattr(clazz, "__name__"): # Escape the type name clazz = ldapfilter.escape_LDAP(clazz.__name__) elif is_string(clazz): # Escape the class name clazz = ldapfilter.escape_LDAP(clazz) if clazz is None: # Directly use the given filter refs_set = sorted(self.__svc_registry.keys()) else: try: # Only for references with the given specification refs_set = iter(self.__svc_specs[clazz]) except KeyError: # No matching specification return None # Parse the filter try: new_filter = ldapfilter.get_ldap_filter(ldap_filter) except ValueError as ex: raise BundleException(ex) if new_filter is not None: # Prepare a generator, as we might not need a complete # walk-through refs_set = ( ref for ref in refs_set if new_filter.matches(ref.get_properties()) ) if only_one: # Return the first element in the list/generator try: return [next(refs_set)] except StopIteration: # No match return None # Get all the matching references return list(refs_set) or None
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 references, or None :raise BundleException: An error occurred looking for service references
4.504469
4.412688
1.020799
with self.__svc_lock: return sorted(self.__bundle_imports.get(bundle, []))
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 the Framework is a very dynamic environment, services can be modified or unregistered at any time. :param bundle: The bundle to look into :return: The references of the services used by this bundle
8.916302
18.853062
0.472937
# type: (Any) -> List[ServiceReference] with self.__svc_lock: return sorted(self.__bundle_svc.get(bundle, []))
def get_bundle_registered_services(self, bundle)
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 :return: The references to the services registered by the bundle
7.593816
13.016865
0.583383
# type: (Any, ServiceReference) -> Any with self.__svc_lock: if reference.is_factory(): return self.__get_service_from_factory(bundle, reference) # Be sure to have the instance try: service = self.__svc_registry[reference] # Indicate the dependency imports = self.__bundle_imports.setdefault(bundle, {}) imports.setdefault(reference, _UsageCounter()).inc() reference.used_by(bundle) return service except KeyError: # Not found raise BundleException( "Service not found (reference: {0})".format(reference) )
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
5.555671
6.44693
0.861754
# type: (Any, ServiceReference) -> Any 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 reference.used_by(bundle) # Check the per-bundle usage counter factory_counter = self.__factory_usage.setdefault( bundle, _FactoryCounter(bundle) ) return factory_counter.get_service(factory, svc_reg) except KeyError: # Not found raise BundleException( "Service not found (reference: {0})".format(reference) )
def __get_service_from_factory(self, bundle, reference)
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
6.189618
6.710313
0.922404
# 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) factory, svc_reg = self.__svc_factories[svc_ref] factory_counter.cleanup_service(factory, svc_reg) elif svc_ref.is_factory(): # Factory service, release it the standard way self.__unget_service_from_factory(bundle, svc_ref) # Clean up local structures try: del self.__factory_usage[bundle] except KeyError: pass try: self.__bundle_imports.pop(bundle).clear() except KeyError: pass
def unget_used_services(self, bundle)
Cleans up all service usages of the given bundle. :param bundle: Bundle to be cleaned up
4.941106
5.044199
0.979562
# type: (Any, ServiceReference, Any) -> bool 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] if not imports[reference].dec(): # No more reference to it del imports[reference] except KeyError: # Unknown reference return False else: # Clean up if not imports: del self.__bundle_imports[bundle] # Update the service reference reference.unused_by(bundle) return True
def unget_service(self, bundle, reference, service=None)
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
4.00865
4.461933
0.898411
# type: (Any, ServiceReference, Any) -> bool 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 reference.unused_by(bundle) # All references have been taken away: clean up if not self.__factory_usage[bundle].is_used(): del self.__factory_usage[bundle] # Remove the service reference from the bundle imports = self.__bundle_imports[bundle] del imports[reference] except KeyError: # Unknown reference return False else: # Clean up if not imports: del self.__bundle_imports[bundle] return True
def __unget_service_from_factory(self, bundle, reference, service=None)
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
4.229971
4.597105
0.920138
# Normalize value value = value.strip() if vtype == TYPE_STRING: # Nothing to do return value elif vtype in TYPES_INT: return int(value) elif vtype in TYPES_FLOAT: return float(value) elif vtype in TYPES_BOOLEAN: # Compare lower-case value return value.lower() not in ("false", "0") elif vtype in TYPES_CHAR: return value[0] # No luck raise ValueError("Unknown value type: {0}".format(vtype))
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
3.111377
3.085608
1.008351
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 # Yep, let the "element" variable be overwritten # pylint: disable=R1704 for element in element: self._indent(element, level + 1, prefix) # Tail of the last child if not element.tail or not element.tail.strip(): element.tail = element_prefix else: if level and (not element.tail or not element.tail.strip()): element.tail = element_prefix
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
2.885699
3.199814
0.901833
values_node = ElementTree.SubElement(props_node, tag) for value in container: value_node = ElementTree.SubElement(values_node, TAG_VALUE) value_node.text = str(value)
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
2.565918
3.273658
0.783808
# 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 # Single value if isinstance(value, int): # Integer return TYPE_LONG elif isinstance(value, float): # Float return TYPE_DOUBLE elif isinstance(value, type(ElementTree.Element(None))): # XML return XML_VALUE # Default: String return TYPE_STRING
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
4.745329
4.822809
0.983935
# Make the ElementTree root = self._make_xml(endpoints) tree = ElementTree.ElementTree(root) # Force the default name space ElementTree.register_namespace("", EDEF_NAMESPACE) # Make the XML for encoding in "unicode", "UTF-8": # Prepare a StringIO output output = StringIO() try: # Try to write with a correct encoding tree.write( output, encoding=encoding, xml_declaration=True, method="xml", ) break except LookupError: # 'unicode' is needed in Python 3, but unknown in Python 2... continue else: raise LookupError("Couldn't find a valid encoding") return output.getvalue()
def to_string(self, endpoints)
Converts the given endpoint description beans into a string :param endpoints: A list of EndpointDescription beans :return: A string containing an XML document
5.317171
5.593241
0.950642
# pylint: disable=W0221 if not self._expected_server_name: # We seem to connect the server anonymously, so SleekXMPP # couldn't find the server host name from the JID # => give it the given server host name as the expected one self._expected_server_name = host # Try to connect if super(BasicBot, self).connect( (host, port), reattempt, use_tls, use_ssl ): # On success, start the processing thread self.process(threaded=True) return True return False
def connect( self, host, port=5222, reattempt=False, use_tls=True, use_ssl=False )
Connects to the server. By default, uses an un-encrypted connection, as it won't connect to an OpenFire server otherwise :param host: Server host name :param port: Server port (default: 5222) :param reattempt: If True, tries to connect to the server until it succeeds :param use_tls: Use STARTTLS :param use_ssl: Server connection is encrypted :return: True if connection succeeded
6.4688
6.533741
0.990061
# pylint: disable=W0613 # Send initial presence self.send_presence(ppriority=self._initial_priority) # Request roster self.get_roster()
def on_session_start(self, data)
XMPP session started
7.285883
5.92992
1.228665
if not self._nick: self._nick = self.boundjid.user # Join the room self.plugin["xep_0045"].joinMUC(data["from"], self._nick)
def on_invite(self, data)
Multi-User Chat invite
5.029032
4.839026
1.039265
# 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 service details info = self["xep_0030"].get_info( jid=item[0], ifrom=self.boundjid.full, block=True, timeout=10, ) if feature in info["disco_info"]["features"]: # The service provides the required feature yield item[0]
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
3.263208
2.948526
1.106725
idx = arg_token.find("=") while idx != -1: if idx != 0 and arg_token[idx - 1] != "\\": # No escape character return idx idx = arg_token.find("=", idx + 1) # No assignment found return -1
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
3.109421
2.765284
1.124449
args = [] kwargs = {} for arg_token in args_list: idx = _find_assignment(arg_token) if idx != -1: # Assignment key = arg_token[:idx] value = arg_token[idx + 1 :] kwargs[key] = value else: # Direct argument args.append(arg_token) # Prepare the dictionary of variables variables = collections.defaultdict(str) variables.update(fw_props) variables.update(session.variables) # Replace variables args = [_ArgTemplate(arg).safe_substitute(variables) for arg in args] kwargs = { key: _ArgTemplate(value).safe_substitute(variables) for key, value in kwargs.items() } return args, kwargs
def _make_args(args_list, session, fw_props)
Converts the given list of arguments into a list (args) and a dictionary (kwargs). All arguments with an assignment are put into kwargs, others in args. :param args_list: The list of arguments to be treated :param session: The current shell session :return: The (arg_token, kwargs) tuple.
2.804553
2.640103
1.062289
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] command = cmd_split[1] if not namespace: # No name space given: given an empty one namespace = "" # Use lower case values only return namespace.lower(), command.lower()
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
3.558078
3.674275
0.968375
if method is None: self._logger.error("No method given for %s.%s", namespace, command) return False # Store everything in lower case namespace = (namespace or "").strip().lower() command = (command or "").strip().lower() if not namespace: namespace = DEFAULT_NAMESPACE if not command: self._logger.error("No command name given") return False if namespace not in self._commands: space = self._commands[namespace] = {} else: space = self._commands[namespace] if command in space: self._logger.error( "Command already registered: %s.%s", namespace, command ) return False space[command] = method return True
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
2.409087
2.378257
1.012963
# type: (str, str) -> CompletionInfo # Find the method (can raise a KeyError) method = self._commands[namespace][command] # Return the completer, if any return getattr(method, ATTR_COMPLETERS, None)
def get_command_completers(self, namespace, command)
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 command or name space
7.905455
8.594768
0.919799
if not namespace: namespace = DEFAULT_NAMESPACE namespace = namespace.strip().lower() if namespace not in self._commands: self._logger.warning("Unknown name space: %s", namespace) return False if command is not None: # Remove the command command = command.strip().lower() if command not in self._commands[namespace]: self._logger.warning( "Unknown command: %s.%s", namespace, command ) return False del self._commands[namespace][command] # Remove the name space if necessary if not self._commands[namespace]: del self._commands[namespace] else: # Remove the whole name space del self._commands[namespace] return True
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
2.21273
2.160598
1.024129
# Look for the spaces where the command name appears namespaces = [] for namespace, commands in self._commands.items(): if command in commands: namespaces.append(namespace) # Sort name spaces namespaces.sort() # Default name space must always come first try: namespaces.remove(DEFAULT_NAMESPACE) namespaces.insert(0, DEFAULT_NAMESPACE) except ValueError: # Default name space wasn't present pass return namespaces
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
4.366231
3.969306
1.099998
namespaces = list(self._commands.keys()) namespaces.remove(DEFAULT_NAMESPACE) namespaces.sort() return namespaces
def get_namespaces(self)
Retrieves the list of known name spaces (without the default one) :return: The list of known name spaces
6.098957
7.201271
0.846928
if not namespace: # Default name space: namespace = DEFAULT_NAMESPACE try: namespace.strip().lower() commands = list(self._commands[namespace].keys()) commands.sort() return commands except KeyError: # Unknown name space return []
def get_commands(self, namespace)
Retrieves the commands of the given name space. If *namespace* is None or empty, it retrieves the commands of the default name space :param namespace: The commands name space :return: A list of commands names
5.630733
5.284369
1.065545
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: # Unknown command raise ValueError("Unknown command {0}".format(command)) else: # Return a sorted list of tuples return sorted((namespace, command) for namespace in spaces) # Single match return [(namespace, command)]
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
5.598032
4.924437
1.136786
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 else: # Ambiguous name raise ValueError( "Multiple name spaces for command '{0}': {1}".format( command, ", ".join(sorted(spaces)) ) ) else: # Use the found name space namespace = spaces[0] # Command found return namespace, command
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
3.506262
3.396209
1.032404
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: session.set(beans.RESULT_VAR_NAME, result) # 0, None are considered as success, so don't use not nor bool return result is not False except TypeError as ex: # Invalid arguments... self._logger.error( "Error calling %s.%s: %s", namespace, command, ex ) session.write_line("Invalid method call: {0}", ex) self.__print_namespace_help(session, namespace, command) return False except Exception as ex: # Error self._logger.exception( "Error calling %s.%s: %s", namespace, command, ex ) session.write_line("{0}: {1}", type(ex).__name__, str(ex)) return False finally: # Try to flush in any case try: session.flush() except IOError: pass
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
3.417927
3.376174
1.012367
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: args.append("[<{0}>={1}]".format(name, value)) else: args.append("[<{0}>]".format(name)) else: # All arguments are mandatory args = ["<{0}>".format(arg) for arg in arg_spec.args[start_arg:]] # Extra arguments if arg_spec.keywords: args.append("[<property=value> ...]") if arg_spec.varargs: args.append("[<{0} ...>]".format(arg_spec.varargs)) # Get the documentation string doc = inspect.getdoc(method) or "(Documentation missing)" return " ".join(args), " ".join(doc.split())
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)
3.032147
2.9725
1.020066
# Extract documentation args, doc = self.__extract_help(self._commands[namespace][cmd_name]) # Print the command name, and its arguments if args: session.write_line("- {0} {1}", cmd_name, args) else: session.write_line("- {0}", cmd_name) # Print the documentation line session.write_line("\t\t{0}", doc)
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
4.086608
4.441055
0.920189
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]] names.sort() else: names = [cmd_name] first_cmd = True for command in names: if not first_cmd: # Print an empty line session.write_line("\n") self.__print_command_help(session, namespace, command) first_cmd = False
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
3.401319
3.303909
1.029483
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 was_namespace: # ... and no name space were matching either -> error session.write_line(str(ex)) return False else: # Print the help of the found command if was_namespace: # Give some space session.write_line("\n\n") for namespace, cmd_name in possibilities: self.__print_namespace_help(session, namespace, cmd_name) else: # Get all name spaces namespaces = list(self._commands.keys()) namespaces.remove(DEFAULT_NAMESPACE) namespaces.sort() namespaces.insert(0, DEFAULT_NAMESPACE) first_ns = True for namespace in namespaces: if not first_ns: # Add empty lines session.write_line("\n\n") # Print the help of all commands self.__print_namespace_help(session, namespace) first_ns = False return None
def print_help(self, session, command=None)
Prints the available methods and their documentation, or the documentation of the given command.
4.264318
4.257738
1.001545
if not kwargs: for name, value in session.variables.items(): session.write_line("{0}={1}".format(name, value)) else: for name, value in kwargs.items(): name = name.strip() session.set(name, value) session.write_line("{0}={1}", name, value)
def var_set(session, **kwargs)
Sets the given variables or prints the current ones. "set answer=42"
2.807703
2.447251
1.147289
name = name.strip() try: session.unset(name) except KeyError: session.write_line("Unknown variable: {0}", name) return False else: session.write_line("Variable {0} unset.", name) return None
def var_unset(session, name)
Unsets the given variable
4.313705
4.261107
1.012344
try: with open(filename, "r") as filep: for lineno, line in enumerate(filep): line = line.strip() if not line or line.startswith("#"): # Ignore comments and empty lines continue # Print out the executed line session.write_line("[{0:02d}] >> {1}", lineno, line) # Execute the line if not self.execute(line, session): session.write_line( "Command at line {0} failed. Abandon.", lineno + 1 ) return False session.write_line("Script execution succeeded") except IOError as ex: session.write_line("Error reading file {0}: {1}", filename, ex) return False return None
def run_file(self, session, filename)
Runs the given "script" file
3.428469
3.347948
1.024051
try: # Internal method return self.funcs[name](*params) except KeyError: # Other method pass # Call the other method outside the except block, to avoid messy logs # in case of error return self._dispatch_method(name, params)
def _simple_dispatch(self, name, params)
Dispatch method
8.454022
8.275812
1.021534
if isinstance(properties, dict): self._properties.update(properties)
def add_properties(self, properties)
Updates the framework properties dictionary :param properties: New framework properties to add
4.556831
6.63934
0.686338
if isinstance(environ, dict): self._environment.update(environ)
def add_environment(self, environ)
Updates the environment dictionary with the given one. Existing entries are overridden by the given ones :param environ: New environment variables
4.586689
6.551233
0.700126
if paths: # Use new paths in priority self._paths = list(paths) + self._paths
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
12.266307
17.130722
0.716041
if components: for component in components: self._components[component["name"]] = ( component["factory"], component.get("properties", {}), )
def add_components(self, components)
Adds a list of components to instantiate :param components: The description of components :raise KeyError: Missing component configuration
5.453713
5.109735
1.067318
# Add environment variables os.environ.update(self._environment) # Normalize paths and avoid duplicates self._paths = remove_duplicates( os.path.realpath(os.path.expanduser(os.path.expandvars(path))) for path in self._paths if os.path.exists(path) ) # Normalize the lists of bundles self._bundles = remove_duplicates(self._bundles)
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.
4.341848
3.285905
1.321355
for path in self.DEFAULT_PATH: # Normalize path path = os.path.expanduser(os.path.expandvars(path)) fullname = os.path.realpath(os.path.join(path, filename)) if os.path.exists(fullname) and os.path.isfile(fullname): yield fullname
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 :return: The complete path to the found files
2.822029
3.213719
0.87812
if not filename: for name in self.find_default(".pelix.conf"): self.load(name) else: with open(filename, "r") as filep: self.__parse(json.load(filep))
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 IOError: Error loading file
6.221904
6.010168
1.03523
for entry in ( "properties", "environment", "paths", "bundles", "components", ): # Check if current values must be reset reset_key = "reset_{0}".format(entry) # Compute the name of the method call_name = "add" if not configuration.get(reset_key) else "set" method = getattr(self.__state, "{0}_{1}".format(call_name, entry)) # Update configuration method(configuration.get(entry))
def __parse(self, configuration)
Parses the given configuration dictionary :param configuration: A configuration as a dictionary (JSON object)
6.03587
6.810532
0.886255
# Normalize configuration self.__state.normalize() # Update sys.path, avoiding duplicates whole_path = list(self.__state.paths) whole_path.extend(sys.path) # Ensure the working directory as first search path sys.path = ["."] for path in whole_path: if path not in sys.path: sys.path.append(path)
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.
6.309227
6.098479
1.034558
with use_ipopo(context) as ipopo: for name, (factory, properties) in self.__state.components.items(): ipopo.instantiate(factory, name, properties)
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 starting a component
7.964602
7.83086
1.017079
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 = '"' if '"' in content: quote_mark = "'" content = content.replace(r"'", r"\'") if '\n' in content: quote_mark *= 3 return 'u'[not is_unicode:]+quote_mark+content+quote_mark
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\'"'
3.911624
2.743105
1.425984
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), is_unicode=True ) else: content = literal[1:-1].decode('string-escape') # keep it escaped if the encoding doesn't work on it try: content.decode(encoding) except UnicodeDecodeError: return literal return literalize_string(content)
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'
3.607729
1.98418
1.818246
'''Unescape all string and unicode literals in bytes.''' return string_literal_re.sub( lambda m: unescape_string_literal(m.group(), encoding), b )
def unescape(b, encoding)
Unescape all string and unicode literals in bytes.
6.826097
4.575036
1.492031
'''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 = lambda b: stream.write( # TODO: the to_bytes makes the behavior different, should we care? unescape(to_bytes(b, unistream.encoding), unistream.encoding) ) return unistream
def make_unistream(stream)
Make a stream which unescapes string literals before writes out.
6.708243
5.290479
1.267984
# 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) for name in arg_info.args: try: output_lines.append( " - {0:s} = {1}".format(name, repr(frame.f_locals[name])) ) except TypeError: # Happens in dict/list-comprehensions in Python 2.x name = name[0] output_lines.append( " - {0:s} = {1}".format(name, repr(frame.f_locals[name])) ) if arg_info.varargs: output_lines.append( " - *{0:s} = {1}".format( arg_info.varargs, frame.f_locals[arg_info.varargs] ) ) if arg_info.keywords: output_lines.append( " - **{0:s} = {1}".format( arg_info.keywords, frame.f_locals[arg_info.keywords] ) ) # Line block lines = _extract_lines(filename, frame.f_globals, line_no, 3) if lines: output_lines.append("") prefix = " " output_lines.append( "{0}{1}".format(prefix, "\n{0}".format(prefix).join(lines)) ) return "\n".join(output_lines)
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
2.412453
2.477062
0.973917
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())) # Smart left strip minimal_tab = None for line in lines: if line.strip(): tab = len(line) - len(line.lstrip()) if minimal_tab is None or tab < minimal_tab: minimal_tab = tab if minimal_tab > 0: lines = [line[minimal_tab:] for line in lines] # Add some place for a marker marked_line = ">> {0}".format(lines[around]) lines = [" {0}".format(line) for line in lines] lines[around] = marked_line lines.append("") return lines
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
2.30828
2.436078
0.94754
return [ ("levels", self.print_levels), ("make", self.make_report), ("clear", self.clear_report), ("show", self.show_report), ("write", self.write_report), ]
def get_methods(self)
Retrieves the list of tuples (command, method) for this command handler
4.334206
3.969923
1.091761
try: # Real name of the level return set(self.__levels[level]) except KeyError: # Alias result = set() for sub_level in self.__aliases[level]: result.update(self.get_level_methods(sub_level)) return result
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
4.305076
3.874588
1.111105
lines = [] for level in sorted(self.get_levels()): methods = sorted( method.__name__ for method in self.get_level_methods(level) ) lines.append("- {0}:".format(level)) lines.append("\t{0}".format(", ".join(methods))) session.write_line("\n".join(lines))
def print_levels(self, session)
Lists available levels
3.271479
3.204849
1.020791
# 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(), } # Paths and line separators for name in "sep", "altsep", "pathsep", "linesep": results["os.{0}".format(name)] = getattr(os, name, None) try: # Available since Python 3.4 results["os.cpu_count"] = os.cpu_count() except AttributeError: results["os.cpu_count"] = None try: # Only for Unix # pylint: disable=E1101 results["sys.dlopenflags"] = sys.getdlopenflags() except AttributeError: results["sys.dlopenflags"] = None return results
def os_details()
Returns a dictionary containing details about the operating system
2.820366
2.801676
1.006671
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", "egid": "getegid", "groups": "getgroups", }.items(): try: results[key] = getattr(os, method)() except (AttributeError, OSError): results[key] = None return results
def process_details()
Returns details about the current process
3.562567
3.32414
1.071726
# 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( info[4][0] for info in socket.getaddrinfo( "localhost", None, socket.AF_INET6 ) ) # Filter addresses ipv6_addresses = sorted(set(ipv6_addresses)) except (socket.gaierror, AttributeError): # AttributeError: AF_INET6 is missing in some versions of Python ipv6_addresses = None return { "IPv4": ipv4_addresses, "IPv6": ipv6_addresses, "host.name": socket.gethostname(), "host.fqdn": socket.getfqdn(), }
def network_details()
Returns details about the network links
1.933367
1.928226
1.002666
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, ... "recursion_limit": sys.getrecursionlimit(), } # Threads implementation details thread_info = getattr(sys, "thread_info", (None, None, None)) results["thread_info.name"] = thread_info[0] results["thread_info.lock"] = thread_info[1] results["thread_info.version"] = thread_info[2] # ABI flags (POSIX only) results["abiflags"] = getattr(sys, "abiflags", None) # -X options (CPython only) results["x_options"] = getattr(sys, "_xoptions", None) return results
def python_details()
Returns a dictionary containing details about the Python interpreter
2.813227
2.770832
1.0153
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_) except TypeError: imported[ module_name ] = "<no file information :: {0}>".format(repr(module_)) return results
def python_modules()
Returns the list of Python modules and their file
3.885122
3.981041
0.975906
framework = self.__context.get_framework() return { "version": framework.get_version(), "properties": framework.get_properties(), }
def pelix_infos(self)
Basic information about the Pelix framework instance
5.612051
4.45683
1.259203
framework = self.__context.get_framework() return { bundle.get_bundle_id(): { "name": bundle.get_symbolic_name(), "version": bundle.get_version(), "state": bundle.get_state(), "location": bundle.get_location(), } for bundle in framework.get_bundles() }
def pelix_bundles(self)
List of installed bundles
2.646297
2.555958
1.035345
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 ), "properties": svc_ref.get_properties(), "bundle.id": svc_ref.get_bundle().get_bundle_id(), "bundle.name": svc_ref.get_bundle().get_symbolic_name(), } for svc_ref in self.__context.get_all_service_references(None) }
def pelix_services(self)
List of registered services
2.158908
2.157765
1.00053
try: with use_ipopo(self.__context) as ipopo: return { name: ipopo.get_factory_details(name) for name in ipopo.get_factories() } except BundleException: # iPOPO is not available: return None
def ipopo_factories(self)
List of iPOPO factories
5.893559
5.411203
1.08914
try: with use_ipopo(self.__context) as ipopo: return { instance[0]: ipopo.get_instance_details(instance[0]) for instance in ipopo.get_instances() } except BundleException: # iPOPO is not available: return None
def ipopo_instances(self)
List of iPOPO instances
5.466191
5.135311
1.064432
results = {} # pylint: disable=W0212 try: # Extract frames frames = sys._current_frames() # Get the thread ID -> Thread mapping names = threading._active.copy() except AttributeError: # Extraction not available return results # Sort by thread ID thread_ids = sorted(frames.keys()) for thread_id in thread_ids: # Get the corresponding stack stack = frames[thread_id] # Try to get the thread name try: name = names[thread_id].name except KeyError: name = "<unknown>" trace_lines = [] frame = stack while frame is not None: # Store the line information trace_lines.append(format_frame_info(frame)) # Previous frame... frame = frame.f_back # Construct the thread description results[thread_id] = { "name": name, "stacktrace": "\n".join(reversed(trace_lines)), } return results
def threads_list()
Lists the active threads and their current code line
3.450232
3.294875
1.047151
if not levels: levels = ["full"] try: # List the methods to call, avoiding double-calls methods = set() for level in levels: methods.update(self.get_level_methods(level)) except KeyError as ex: # Unknown level session.write_line("Unknown report level: {0}", ex) self.__report = None else: # Call each method self.__report = {method.__name__: method() for method in methods} # Describe the report self.__report["report"] = { "report.levels": levels, "time.stamp": time.time(), "time.local": str(datetime.datetime.now()), "time.utc": str(datetime.datetime.utcnow()), } return self.__report
def make_report(self, session, *levels)
Prepares the report at the requested level(s)
4.075171
3.944652
1.033088
# Don't forget the empty line at the end of the file return ( json.dumps( data, sort_keys=True, indent=4, separators=(",", ": "), default=self.json_converter, ) + "\n" )
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
3.444742
3.738613
0.921396
if levels: self.make_report(session, *levels) if self.__report: session.write_line(self.to_json(self.__report)) else: session.write_line("No report to show")
def show_report(self, session, *levels)
Shows the report that has been generated
4.741529
4.64355
1.0211
if not self.__report: session.write_line("No report to write down") return try: with open(filename, "w+") as out_file: out_file.write(self.to_json(self.__report)) except IOError as ex: session.write_line("Error writing to file: {0}", ex)
def write_report(self, session, filename)
Writes the report in JSON format to the given file
3.89562
3.647167
1.068122
if not self._error and not self._result: # Store results, if not already set self._error = error self._result = result # Unlock the call self._event.set()
def handle_result(self, result, error)
The result has been received :param result: Call result :param error: Error message
6.822988
7.729253
0.882749
print( "EventListenerHookImpl: service_event=", service_event, ", listener_dict=", listener_dict, sep="", ) # Remove it if it's our service context, has the "to_filter" property # and it's the 3rd time through the hook svc_ref = service_event.get_service_reference() to_filter = svc_ref.get_property("to_filter") if self._context in listener_dict and to_filter: if self._count >= 3: print( "EventListenerHookSample removing our service listener " "so it will not be notified" ) listener_dict.pop(self._context) else: self._count += 1
def event(self, service_event, listener_dict)
A service has been received: this method can alter the list of listeners to be notified of this event (remove only). It can also be used as a handler for the event that will be called before any standard one. :param service_event: The ServiceEvent being triggered :param listener_dict: A dictionary associating a bundle context to a list of listeners
5.481052
5.495815
0.997314
# 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 to grab a service and to use it inside a # with block. It automatically releases the service when exiting the block, # even if an exception was raised with use_service(context, ref_config) as svc_config: # Here, svc_config points to the spell checker service passage = "Welcome to our framwork iPOPO" print("1. Testing Spell Checker:", passage) misspelled_words = svc_config.check(passage) print("> Misspelled_words are:", misspelled_words) # Start the spell client bundle, which provides a shell command context.install_bundle("spell_client").start() # Wait for the framework to stop framework.wait_for_stop()
def main()
Starts a Pelix framework and waits for it to stop
5.573623
5.321823
1.047315
# Log warnings when some logger = logging.getLogger("ssl_wrap") def _password_support_error(): 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 context.load_cert_chain(certfile, keyfile, password) except TypeError: # The "password" argument isn't supported # Check support for key file password _password_support_error() # Load the certificate, without the password argument context.load_cert_chain(certfile, keyfile) # Return the wrapped socket return context.wrap_socket(socket, server_side=True) except AttributeError as ex: # Log a warning to advise the user of possible security holes logger.warning( "Can't create a custom SSLContext. " "The server should be considered insecure." ) logger.debug("Missing attribute: %s", ex) # Check support for key file password _password_support_error() # Fall back to the "old" wrap_socket method return ssl.wrap_socket( socket, server_side=True, certfile=certfile, keyfile=keyfile )
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
4.316206
4.12994
1.045101
# type: (Iterable[Any], str) -> str html_list = "\n".join( '<li><a href="{0}">{0}</a></li>'.format(item) for item in items ) return "<{0}>\n{1}\n</{0}>".format(tag, html_list)
def make_html_list(items, tag="ul")
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
2.401454
3.478626
0.690345
# type: () -> ByteString try: size = int(self.get_header("content-length")) except (ValueError, TypeError): size = -1 return self.get_rfile().read(size)
def read_data(self)
Reads all the data in the input stream :return: The read data
5.55757
7.557364
0.735385