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 _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 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 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 _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 __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 __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))
