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 _bt_query_from_native(cls, priv_query_exec_ptr, object_name, params_ptr, method_obj): # this can raise, but the native side checks the exception if params_ptr is not None: params = bt2_value._create_from_const_ptr_and_get_ref(params_ptr) else: params = None priv_query_exec = bt2_query_executor._PrivateQueryExecutor( priv_query_exec_ptr) try: # this can raise, but the native side checks the exception results = cls._user_query(priv_query_exec, object_name, params, method_obj) finally: # the private query executor is a private view on the query # executor; it's not a shared object (the library does not # offer an API to get/put a reference, just like "self" # objects) from this query's point of view, so invalidate # the object in case the user kept a reference and uses it # later priv_query_exec._invalidate() # this can raise, but the native side checks the exception results = bt2.create_value(results) if results is None: results_ptr = native_bt.value_null else: results_ptr = results._ptr # return new reference bt2_value._Value._get_ref(results_ptr) return int(results_ptr)
def _query_from_native(cls, query_exec_ptr, obj, params_ptr): # this can raise, in which case the native call to # bt_component_class_query() returns NULL if params_ptr is not None: native_bt.get(params_ptr) params = bt2.values._create_from_ptr(params_ptr) else: params = None native_bt.get(query_exec_ptr) query_exec = bt2.QueryExecutor._create_from_ptr(query_exec_ptr) # this can raise, but the native side checks the exception results = cls._query(query_exec, obj, params) if results is NotImplemented: return results # this can raise, but the native side checks the exception results = bt2.create_value(results) if results is None: results_addr = int(native_bt.value_null) else: # return new reference results._get() results_addr = int(results._ptr) return results_addr
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 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__(self, params, obj, logging_level): if logging_level is not None: utils._check_log_level(logging_level) self._params = bt2.create_value(params) self._obj = obj self._logging_level = logging_level
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 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 __call__(self, params=None, name=None): params = bt2.create_value(params) comp_ptr = native_bt.component_create_with_init_method_data( self._ptr, name, params._ptr, None) if comp_ptr is None: raise bt2.CreationError('cannot create component object') return _create_generic_component_from_ptr(comp_ptr)
def __init__( self, plugin_name, class_name, params=None, obj=None, logging_level=bt2_logging.LoggingLevel.NONE, ): utils._check_str(plugin_name) utils._check_str(class_name) utils._check_log_level(logging_level) self._plugin_name = plugin_name self._class_name = class_name self._logging_level = logging_level self._obj = obj if type(params) is str: self._params = bt2.create_value({'inputs': [params]}) else: self._params = bt2.create_value(params)
def __call__(self, params=None, name=None): params = bt2.create_value(params) comp_ptr = native_bt.component_create_with_init_method_data(self._ptr, name, params._ptr, None) if comp_ptr is None: raise bt2.CreationError('cannot create component object') return _create_generic_component_from_ptr(comp_ptr)
def test_query_gets_same_params(self): class MySink(bt2.UserSinkComponent): def _consume(self): pass @staticmethod def _query(obj, params): nonlocal recv_params recv_params = params recv_params = NotImplemented params = bt2.create_value(23) MySink.query('allo', params) self.assertEqual(recv_params.addr, params.addr)
def _query_from_bt(cls, action, params): # this can raise, in which case the native call to # bt_component_class_query() returns NULL results = cls._query(action, params) results = bt2.create_value(results) if results is None: results_addr = int(native_bt.value_null) else: # steal the underlying native value object for the caller results_addr = int(results._ptr) results._ptr = None return results_addr
def __init__(self, component_class, object_name, params=None, method_obj=None): if not isinstance(component_class, _bt2_component()._ComponentClassConst): 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_name) if params is None: params_ptr = native_bt.value_null else: params = bt2.create_value(params) params_ptr = params._ptr cc_ptr = component_class._bt_component_class_ptr() assert cc_ptr is not None if method_obj is not None and not native_bt.bt2_is_python_component_class( cc_ptr): raise ValueError( 'cannot pass a Python object to a non-Python component class') ptr = native_bt.bt2_query_executor_create(cc_ptr, object_name, params_ptr, method_obj) if ptr is None: raise bt2._MemoryError('cannot create query executor object') super().__init__(ptr) # Keep a reference of `method_obj` as the native query executor # does not have any. This ensures that, when this object's # query() method is called, the Python object still exists. self._method_obj = method_obj
def add_sink_component(self, component_class, name, params=None): if issubclass(component_class, bt2.component._UserSinkComponent): cc_ptr = component_class._cc_ptr else: raise TypeError("'{}' is not a sink component class".format( component_class.__class__.__name__)) utils._check_str(name) params = bt2.create_value(params) params_ptr = params._ptr if params is not None else None status, comp_ptr = native_bt.graph_add_sink_component(self._ptr, cc_ptr, name, params_ptr) self._handle_status(status, 'cannot add sink component to graph') assert(comp_ptr) return bt2.component._create_component_from_ptr(comp_ptr, native_bt.COMPONENT_CLASS_TYPE_SINK)
def __init__(self, component_class, params=None, obj=None): if (not _is_source_comp_cls(component_class) and not _is_filter_comp_cls(component_class) and not _is_sink_comp_cls(component_class)): raise TypeError("'{}' is not a component class".format( component_class.__class__.__name__)) 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') self._comp_cls = component_class self._params = bt2.create_value(params) self._obj = obj
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)
def append_option(self, name, field_class, user_attributes=None): utils._check_str(name) utils._check_type(field_class, _FieldClass) if name in self: raise ValueError("duplicate option name '{}'".format(name)) 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) status = native_bt.field_class_variant_without_selector_append_option( self._ptr, name, field_class._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 append_member(self, name, field_class, user_attributes=None): utils._check_str(name) utils._check_type(field_class, _FieldClass) if name in self: raise ValueError("duplicate member name '{}'".format(name)) 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) status = native_bt.field_class_structure_append_member( self._ptr, name, field_class._ptr ) utils._handle_func_status( status, 'cannot append member to structure field class object' ) if user_attributes is not None: self[name]._user_attributes = user_attributes_value
def __setitem__(self, key, value): utils._check_str(key) value = bt2.create_value(value) ret = native_bt.ctf_event_class_set_attribute(self._event_class_ptr, key, value._ptr) utils._handle_ret(ret, "cannot set event class object's attribute")
def _test_binop_rhs_neg_vint(self, test_cb, op): test_cb(op, bt2.create_value(-23))
def _test_binop_rhs_pos_vfloat(self, test_cb, op): test_cb(op, bt2.create_value(2.2))
def _test_binop_rhs_zero_vfloat(self, test_cb, op): test_cb(op, bt2.create_value(0.0))
def _test_binop_rhs_neg_vfloat(self, test_cb, op): test_cb(op, bt2.create_value(-23.4))