def __init__(self, name, description=None, frequency=None, precision=None, offset=None, is_absolute=None, uuid=None): utils._check_str(name) ptr = native_bt.ctf_clock_class_create(name) if ptr is None: raise bt2.CreationError('cannot create clock class object') super().__init__(ptr) if description is not None: self.description = description if frequency is not None: self.frequency = frequency if precision is not None: self.precision = precision if offset is not None: self.offset = offset if is_absolute is not None: self.is_absolute = is_absolute if uuid is not None: self.uuid = uuid
def query(self, component_class, object, params=None): if self.is_canceled: raise bt2.QueryExecutorCanceled if not isinstance(component_class, bt2.component._GenericComponentClass): err = False try: if not issubclass(component_class, bt2.component._UserComponent): err = True except TypeError: err = True if err: o = component_class raise TypeError("'{}' is not a component class object".format(o)) utils._check_str(object) if params is None: params_ptr = native_bt.value_null else: params = bt2.create_value(params) params_ptr = params._ptr cc_ptr = component_class._component_class_ptr() status, result_ptr = native_bt.query_executor_query(self._ptr, cc_ptr, object, params_ptr) self._handle_status(status, 'cannot query component class') assert(result_ptr) return bt2.value._create_from_ptr(result_ptr)
def __setitem__(self, key, value): utils._check_str(key) value = bt2.create_value(value) ret = native_bt.trace_set_environment_field(self._trace._ptr, key, value._ptr) utils._handle_ret(ret, "cannot set trace class object's environment entry")
def __init__(self, name, id=None, log_level=None, emf_uri=None, context_field_class=None, payload_field_class=None): utils._check_str(name) ptr = native_bt.event_class_create(name) if ptr is None: raise bt2.CreationError('cannot create event class object') super().__init__(ptr) if id is not None: self.id = id if log_level is not None: self.log_level = log_level if emf_uri is not None: self.emf_uri = emf_uri if context_field_class is not None: self.context_field_class = context_field_class if payload_field_class is not None: self.payload_field_class = payload_field_class
def append_option(self, name, field_class, ranges, user_attributes=None): utils._check_str(name) utils._check_type(field_class, _FieldClass) utils._check_type(ranges, self._variant_option_pycls._range_set_pycls) if name in self: raise ValueError("duplicate option name '{}'".format(name)) if len(ranges) == 0: raise ValueError('range set is empty') user_attributes_value = None if user_attributes is not None: # check now that user attributes are valid user_attributes_value = bt2.create_value(user_attributes) # TODO: check overlaps (precondition of self._append_option()) status = self._append_option(self._ptr, name, field_class._ptr, ranges._ptr) utils._handle_func_status( status, 'cannot append option to variant field class object' ) if user_attributes is not None: self[name]._user_attributes = user_attributes_value
def __init__(cls, class_name, bases, namespace, **kwargs): super().__init__(class_name, bases, namespace) # skip our own bases; they are never directly instantiated by the user own_bases = ( '_UserComponent', '_UserFilterSinkComponent', '_UserSourceComponent', '_UserFilterComponent', '_UserSinkComponent', ) if class_name in own_bases: return comp_cls_name = kwargs.get('name', class_name) utils._check_str(comp_cls_name) comp_cls_descr = None comp_cls_help = None if hasattr(cls, '__doc__') and cls.__doc__ is not None: utils._check_str(cls.__doc__) docstring = _trim_docstring(cls.__doc__) lines = docstring.splitlines() if len(lines) >= 1: comp_cls_descr = lines[0] if len(lines) >= 3: comp_cls_help = '\n'.join(lines[2:]) iter_cls = kwargs.get('message_iterator_class') if _UserSourceComponent in bases: _UserComponentType._set_iterator_class(cls, iter_cls) cc_ptr = native_bt.py3_component_class_source_create(cls, comp_cls_name, comp_cls_descr, comp_cls_help) elif _UserFilterComponent in bases: _UserComponentType._set_iterator_class(cls, iter_cls) cc_ptr = native_bt.py3_component_class_filter_create(cls, comp_cls_name, comp_cls_descr, comp_cls_help) elif _UserSinkComponent in bases: if not hasattr(cls, '_consume'): raise bt2.IncompleteUserClass("cannot create component class '{}': missing a _consume() method".format(class_name)) cc_ptr = native_bt.py3_component_class_sink_create(cls, comp_cls_name, comp_cls_descr, comp_cls_help) else: raise bt2.IncompleteUserClass("cannot find a known component class base in the bases of '{}'".format(class_name)) if cc_ptr is None: raise bt2.CreationError("cannot create component class '{}'".format(class_name)) cls._cc_ptr = cc_ptr
def __init__(self, name, id=None, context_field_type=None, payload_field_type=None, attributes=None): utils._check_str(name) ptr = native_bt.ctf_event_class_create(name) if ptr is None: raise bt2.CreationError('cannot create event class object') super().__init__(ptr) if id is not None: self.id = id if context_field_type is not None: self.context_field_type = context_field_type if payload_field_type is not None: self.payload_field_type = payload_field_type if attributes is not None: for name, value in attributes.items(): self.attributes[name] = value
def __init__(self, element_field_class, length_name): utils._check_type(element_field_class, _FieldClass) utils._check_str(length_name) ptr = native_bt.field_class_sequence_create(element_field_class._ptr, length_name) self._check_create_status(ptr) super().__init__(ptr)
def find_plugin( name, find_in_std_env_var=True, find_in_user_dir=True, find_in_sys_dir=True, find_in_static=True, fail_on_load_error=False, ): utils._check_str(name) utils._check_bool(fail_on_load_error) status, ptr = native_bt.bt2_plugin_find( name, int(find_in_std_env_var), int(find_in_user_dir), int(find_in_sys_dir), int(find_in_static), int(fail_on_load_error), ) if status == native_bt.__BT_FUNC_STATUS_NOT_FOUND: return utils._handle_func_status(status, 'failed to find plugin') assert ptr is not None return _Plugin._create_from_ptr(ptr)
def __init__(self, name, description=None, frequency=None, precision=None, offset=None, is_absolute=None, uuid=None): utils._check_str(name) ptr = native_bt.ctf_clock_create(name) if ptr is None: raise bt2.CreationError('cannot create CTF writer clock object') super().__init__(ptr) if description is not None: self.description = description if frequency is not None: self.frequency = frequency if precision is not None: self.precision = precision if offset is not None: self.offset = offset if is_absolute is not None: self.is_absolute = is_absolute if uuid is not None: self.uuid = uuid
def query(self, component_class, object, params=None): if self.is_canceled: raise bt2.QueryExecutorCanceled if not isinstance(component_class, bt2.component._GenericComponentClass): err = False try: if not issubclass(component_class, bt2.component._UserComponent): err = True except TypeError: err = True if err: o = component_class raise TypeError("'{}' is not a component class object".format(o)) utils._check_str(object) if params is None: params_ptr = native_bt.value_null else: params = bt2.create_value(params) params_ptr = params._ptr cc_ptr = component_class._component_class_ptr() status, result_ptr = native_bt.query_executor_query(self._ptr, cc_ptr, object, params_ptr) self._handle_status(status, 'cannot query component class') assert(result_ptr) return bt2.value._create_from_ptr(result_ptr)
def __init__(self, element_field_type, length_name): utils._check_type(element_field_type, _FieldType) utils._check_str(length_name) ptr = native_bt.ctf_field_type_sequence_create(element_field_type._ptr, length_name) self._check_create_status(ptr) super().__init__(ptr)
def __init__(self, element_field_class, length_name): utils._check_type(element_field_class, _FieldClass) utils._check_str(length_name) ptr = native_bt.field_class_sequence_create(element_field_class._ptr, length_name) self._check_create_status(ptr) super().__init__(ptr)
def append_field(self, name, field_class): utils._check_str(name) utils._check_type(field_class, _FieldClass) ret = self._add_field(field_class._ptr, name) utils._handle_ret( ret, "cannot add field to {} field class object".format( self._NAME.lower()))
def __init__(cls, class_name, bases, namespace, **kwargs): super().__init__(class_name, bases, namespace) # skip our own bases; they are never directly instantiated by the user own_bases = ( '_UserComponent', '_UserFilterSinkComponent', '_UserSourceComponent', '_UserFilterComponent', '_UserSinkComponent', ) if class_name in own_bases: return comp_cls_name = kwargs.get('name', class_name) utils._check_str(comp_cls_name) comp_cls_descr = None comp_cls_help = None if hasattr(cls, '__doc__') and cls.__doc__ is not None: utils._check_str(cls.__doc__) docstring = _trim_docstring(cls.__doc__) lines = docstring.splitlines() if len(lines) >= 1: comp_cls_descr = lines[0] if len(lines) >= 3: comp_cls_help = '\n'.join(lines[2:]) iter_cls = kwargs.get('message_iterator_class') if _UserSourceComponent in bases: _UserComponentType._bt_set_iterator_class(cls, iter_cls) cc_ptr = native_bt.bt2_component_class_source_create( cls, comp_cls_name, comp_cls_descr, comp_cls_help) elif _UserFilterComponent in bases: _UserComponentType._bt_set_iterator_class(cls, iter_cls) cc_ptr = native_bt.bt2_component_class_filter_create( cls, comp_cls_name, comp_cls_descr, comp_cls_help) elif _UserSinkComponent in bases: if not hasattr(cls, '_user_consume'): raise bt2._IncompleteUserClass( "cannot create component class '{}': missing a _user_consume() method" .format(class_name)) cc_ptr = native_bt.bt2_component_class_sink_create( cls, comp_cls_name, comp_cls_descr, comp_cls_help) else: raise bt2._IncompleteUserClass( "cannot find a known component class base in the bases of '{}'" .format(class_name)) if cc_ptr is None: raise bt2._MemoryError( "cannot create component class '{}'".format(class_name)) cls._bt_cc_ptr = cc_ptr
def add_component( self, component_class, name, params=None, obj=None, logging_level=bt2_logging.LoggingLevel.NONE, ): if isinstance(component_class, bt2_component._SourceComponentClassConst): cc_ptr = component_class._ptr add_fn = native_bt.bt2_graph_add_source_component cc_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE elif isinstance(component_class, bt2_component._FilterComponentClassConst): cc_ptr = component_class._ptr add_fn = native_bt.bt2_graph_add_filter_component cc_type = native_bt.COMPONENT_CLASS_TYPE_FILTER elif isinstance(component_class, bt2_component._SinkComponentClassConst): cc_ptr = component_class._ptr add_fn = native_bt.bt2_graph_add_sink_component cc_type = native_bt.COMPONENT_CLASS_TYPE_SINK elif issubclass(component_class, bt2_component._UserSourceComponent): cc_ptr = component_class._bt_cc_ptr add_fn = native_bt.bt2_graph_add_source_component cc_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE elif issubclass(component_class, bt2_component._UserSinkComponent): cc_ptr = component_class._bt_cc_ptr add_fn = native_bt.bt2_graph_add_sink_component cc_type = native_bt.COMPONENT_CLASS_TYPE_SINK elif issubclass(component_class, bt2_component._UserFilterComponent): cc_ptr = component_class._bt_cc_ptr add_fn = native_bt.bt2_graph_add_filter_component cc_type = native_bt.COMPONENT_CLASS_TYPE_FILTER else: raise TypeError( "'{}' is not a component class".format( component_class.__class__.__name__ ) ) utils._check_str(name) utils._check_log_level(logging_level) base_cc_ptr = component_class._bt_component_class_ptr() if obj is not None and not native_bt.bt2_is_python_component_class(base_cc_ptr): raise ValueError('cannot pass a Python object to a non-Python component') if params is not None and not isinstance(params, (dict, bt2.MapValue)): raise TypeError("'params' parameter is not a 'dict' or a 'bt2.MapValue'.") params = bt2.create_value(params) params_ptr = params._ptr if params is not None else None status, comp_ptr = add_fn( self._ptr, cc_ptr, name, params_ptr, obj, logging_level ) utils._handle_func_status(status, 'cannot add component to graph') assert comp_ptr return bt2_component._create_component_from_const_ptr(comp_ptr, cc_type)
def _add_input_port(self, name, user_data=None): utils._check_str(name) fn = native_bt.self_component_sink_add_input_port comp_status, self_port_ptr = fn(self._bt_ptr, name, user_data) utils._handle_func_status( comp_status, 'cannot add input port to sink component object') assert self_port_ptr return bt2_port._UserComponentInputPort._create_from_ptr(self_port_ptr)
def __getitem__(self, key): utils._check_str(key) cc_ptr = native_bt.trace_get_clock_class_by_name(self._trace._ptr, key) if cc_ptr is None: raise KeyError(key) return bt2.ClockClass._create_from_ptr(cc_ptr)
def __getitem__(self, key): utils._check_str(key) port_ptr = self._borrow_port_ptr_by_name(self._component_ptr, key) if port_ptr is None: raise KeyError(key) return self._port_pycls._create_from_ptr_and_get_ref(port_ptr)
def __getitem__(self, label): utils._check_str(label) mapping_ptr = self._borrow_mapping_ptr_by_label(self._ptr, label) if mapping_ptr is None: raise KeyError(label) return self._mapping_pycls(mapping_ptr)
def __getitem__(self, key): utils._check_str(key) ptr = native_bt.ctf_field_structure_get_field(self._ptr, key) if ptr is None: raise KeyError(key) return _create_from_ptr(ptr)
def create_plugin_from_name(name): utils._check_str(name) plugin_ptr = native_bt.plugin_create_from_name(name) if plugin_ptr is None: raise bt2.NoSuchPluginError(name) return _Plugin._create_from_ptr(plugin_ptr)
def create_plugins_from_dir(path, recurse=True): utils._check_str(path) plugin_ptrs = native_bt.py3_plugin_create_all_from_dir(path, recurse) if plugin_ptrs is None: raise bt2.Error('cannot get plugin objects from directory') return _plugin_ptrs_to_plugins(plugin_ptrs)
def create_plugins_from_file(path): utils._check_str(path) plugin_ptrs = native_bt.py3_plugin_create_all_from_file(path) if plugin_ptrs is None: raise bt2.Error('cannot get plugin objects from file') return _plugin_ptrs_to_plugins(plugin_ptrs)
def __getitem__(self, key): utils._check_str(key) ptr = native_bt.field_structure_get_field_by_name(self._ptr, key) if ptr is None: raise KeyError(key) return _create_from_ptr(ptr)
def __getitem__(self, key): utils._check_str(key) cc_ptr = self._borrow_component_class_by_name(self._plugin._ptr, key) if cc_ptr is None: raise KeyError(key) return bt2.component._create_component_class_from_ptr_and_get_ref(cc_ptr, self._comp_cls_type)
def _add_input_port(self, name): utils._check_str(name) fn = native_bt.private_component_sink_add_input_private_port comp_status, priv_port_ptr = fn(self._ptr, name, None) _handle_component_status(comp_status, 'cannot add input port to sink component object') assert(priv_port_ptr) return bt2.port._create_private_from_ptr(priv_port_ptr)
def find_plugin(name): utils._check_str(name) ptr = native_bt.plugin_find(name) if ptr is None: return return _Plugin._create_from_ptr(ptr)
def __getitem__(self, label): utils._check_str(label) mapping = self._get_mapping_by_label(self._ptr, label) if mapping is None: raise KeyError(label) return mapping
def _add_input_port(self, name): utils._check_str(name) fn = native_bt.private_component_sink_add_input_private_port comp_status, priv_port_ptr = fn(self._ptr, name, None) _handle_component_status( comp_status, 'cannot add input port to sink component object') assert (priv_port_ptr) return bt2.port._create_private_from_ptr(priv_port_ptr)
def __getitem__(self, key): utils._check_str(key) cc_ptr = native_bt.trace_get_clock_class_by_name(self._trace._ptr, key) if cc_ptr is None: raise KeyError(key) return bt2.ClockClass._create_from_ptr(cc_ptr)
def find_plugin(name): utils._check_str(name) ptr = native_bt.plugin_find(name) if ptr is None: return return _Plugin._create_from_ptr(ptr)
def __init__(self, path): utils._check_str(path) ptr = native_bt.ctf_writer_create(path) if ptr is None: raise bt2.CreationError('cannot create CTF writer object') super().__init__(ptr)
def __init__(self, path): utils._check_str(path) ptr = native_bt.ctf_writer_create(path) if ptr is None: raise bt2.CreationError('cannot create CTF writer object') super().__init__(ptr)
def __getitem__(self, key): utils._check_str(key) cc_ptr = native_bt.plugin_get_component_class_by_name_and_type( self._plugin._ptr, key, self._comp_cls_type) if cc_ptr is None: raise KeyError(key) return bt2.component._create_generic_component_class_from_ptr(cc_ptr)
def __getitem__(self, key): utils._check_str(key) cc_ptr = self._borrow_component_class_by_name(self._plugin._ptr, key) if cc_ptr is None: raise KeyError(key) return bt2_component._create_component_class_from_const_ptr_and_get_ref( cc_ptr, self._comp_cls_type)
def __getitem__(self, key): utils._check_str(key) ec_ptr = native_bt.ctf_stream_class_get_event_class_by_name( self._ptr, key) if ec_ptr is None: raise KeyError(key) return bt2.EventClass._create_from_ptr(ec_ptr)
def __getitem__(self, key): utils._check_str(key) value_ptr = native_bt.trace_get_environment_field_value_by_name(self._trace._ptr, key) if value_ptr is None: raise KeyError(key) return bt2.value._create_from_ptr(value_ptr)
def __getitem__(self, key): utils._check_str(key) ec_ptr = native_bt.ctf_stream_class_get_event_class_by_name(self._ptr, key) if ec_ptr is None: raise KeyError(key) return bt2.EventClass._create_from_ptr(ec_ptr)
def _add_output_port(self, name, user_data=None): utils._check_str(name) fn = native_bt.self_component_filter_add_output_port comp_status, self_port_ptr = fn(self._bt_ptr, name, user_data) utils._handle_func_status( comp_status, 'cannot add output port to filter component object') assert self_port_ptr return bt2_port._UserComponentOutputPort._create_from_ptr_and_get_ref( self_port_ptr)
def __getitem__(self, key): utils._check_str(key) value_ptr = native_bt.ctf_event_class_get_attribute_value_by_name(self._event_class_ptr, key) if value_ptr is None: raise KeyError(key) return bt2.values._create_from_ptr(value_ptr)
def __getitem__(self, key): utils._check_str(key) value_ptr = native_bt.trace_get_environment_field_value_by_name(self._trace._ptr, key) if value_ptr is None: raise KeyError(key) return bt2.values._create_from_ptr(value_ptr)
def __getitem__(self, key): utils._check_str(key) value_ptr = native_bt.ctf_event_class_get_attribute_value_by_name( self._event_class_ptr, key) if value_ptr is None: raise KeyError(key) return bt2.values._create_from_ptr(value_ptr)
def __init__(self, plugin_name, component_class_name, params=None): utils._check_str(plugin_name) utils._check_str(component_class_name) self._plugin_name = plugin_name self._component_class_name = component_class_name if type(params) is str: self._params = bt2.create_value({'path': params}) else: self._params = bt2.create_value(params)
def sink_component_class(self, name): utils._check_str(name) cc_ptr = native_bt.plugin_get_component_class_by_name_and_type(self._ptr, name, native_bt.COMPONENT_CLASS_TYPE_SINK) if cc_ptr is None: return return bt2.component._create_generic_component_class_from_ptr(cc_ptr)
def __getitem__(self, key): utils._check_str(key) cc_ptr = native_bt.plugin_get_component_class_by_name_and_type(self._plugin._ptr, key, self._comp_cls_type) if cc_ptr is None: raise KeyError(key) return bt2.component._create_generic_component_class_from_ptr(cc_ptr)
def __call__(self, name=None): if name is not None: utils._check_str(name) stream_ptr = native_bt.ctf_stream_create(self._ptr, name) if stream_ptr is None: raise bt2.CreationError('cannot create stream object') return bt2.stream._create_from_ptr(stream_ptr)
def __getitem__(self, key): utils._check_str(key) port_ptr = self._get_port_by_name_fn(self._component._ptr, key) if port_ptr is None: raise KeyError(key) if self._is_private: return bt2.port._create_private_from_ptr(port_ptr) else: return bt2.port._create_from_ptr(port_ptr)
def __init__(self, tag_name, tag_field_type=None): utils._check_str(tag_name) if tag_field_type is None: tag_ft_ptr = None else: utils._check_type(tag_field_type, EnumerationFieldType) tag_ft_ptr = tag_field_type._ptr ptr = native_bt.field_type_variant_create(tag_ft_ptr, tag_name) self._check_create_status(ptr) super().__init__(ptr)
def __init__(self, tag_name, tag_field_class=None): utils._check_str(tag_name) if tag_field_class is None: tag_fc_ptr = None else: utils._check_type(tag_field_class, EnumerationFieldClass) tag_fc_ptr = tag_field_class._ptr ptr = native_bt.field_class_variant_create(tag_fc_ptr, tag_name) self._check_create_status(ptr) super().__init__(ptr)
def register_plugin(module_name, name, description=None, author=None, license=None, version=None): import sys if module_name not in sys.modules: raise RuntimeError("cannot find module '{}' in loaded modules".format(module_name)) utils._check_str(name) if description is not None: utils._check_str(description) if author is not None: utils._check_str(author) if license is not None: utils._check_str(license) if version is not None: if not _validate_version(version): raise ValueError('wrong version: expecting a tuple: (major, minor, patch) or (major, minor, patch, extra)') sys.modules[module_name]._bt_plugin_info = _PluginInfo(name, description, author, license, version)
def find_plugins(path, recurse=True): utils._check_str(path) utils._check_bool(recurse) plugin_set_ptr = None if os.path.isfile(path): plugin_set_ptr = native_bt.plugin_create_all_from_file(path) elif os.path.isdir(path): plugin_set_ptr = native_bt.plugin_create_all_from_dir(path, int(recurse)) if plugin_set_ptr is None: return return _PluginSet._create_from_ptr(plugin_set_ptr)
def create_notification_iterator(self, notification_types=None, colander_component_name=None): notif_types = bt2.notification._notif_types_from_notif_classes(notification_types) if colander_component_name is not None: utils._check_str(colander_component_name) notif_iter_ptr = native_bt.py3_create_output_port_notif_iter(int(self._ptr), colander_component_name, notif_types) if notif_iter_ptr is None: raise bt2.CreationError('cannot create output port notification iterator') return bt2.notification_iterator._OutputPortNotificationIterator._create_from_ptr(notif_iter_ptr)
def add_mapping(self, name, lower, upper=None): utils._check_str(name) if upper is None: upper = lower if self.is_signed: add_fn = native_bt.field_class_enumeration_add_mapping_signed utils._check_int64(lower) utils._check_int64(upper) else: add_fn = native_bt.field_class_enumeration_add_mapping_unsigned utils._check_uint64(lower) utils._check_uint64(upper) ret = add_fn(self._ptr, name, lower, upper) utils._handle_ret(ret, "cannot add mapping to enumeration field class object")
def _query(comp_cls_ptr, obj, params): utils._check_str(obj) if params is None: params_ptr = native_bt.value_null else: params = bt2.create_value(params) params_ptr = params._ptr results_ptr = native_bt.component_class_query(comp_cls_ptr, obj, params_ptr) if results_ptr is None: raise bt2.Error('cannot query info with object "{}"'.format(obj)) if results_ptr == native_bt.value_null: return return bt2.values._create_from_ptr(results_ptr)
def add_component(self, component_class, name, params=None): if isinstance(component_class, bt2.component._GenericComponentClass): cc_ptr = component_class._ptr elif issubclass(component_class, bt2.component._UserComponent): cc_ptr = component_class._cc_ptr else: raise TypeError("'{}' is not a component class".format(component_class.__class__.__name__)) utils._check_str(name) params = bt2.create_value(params) if params is None: params_ptr = None else: params_ptr = params._ptr status, comp_ptr = native_bt.graph_add_component(self._ptr, cc_ptr, name, params_ptr) self._handle_status(status, 'cannot add component to graph') assert(comp_ptr) return bt2.component._create_generic_component_from_ptr(comp_ptr)