1 # SPDX-License-Identifier: MIT
3 # Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
5 from bt2
import native_bt
, object, utils
6 from bt2
import message_iterator
as bt2_message_iterator
8 from bt2
import value
as bt2_value
9 from bt2
import trace_class
as bt2_trace_class
10 from bt2
import clock_class
as bt2_clock_class
11 from bt2
import query_executor
as bt2_query_executor
12 from bt2
import port
as bt2_port
17 # This class wraps a component class pointer. This component class could
18 # have been created by Python code, but since we only have the pointer,
19 # we can only wrap it in a generic way and lose the original Python
22 # Subclasses must implement some methods that this base class uses:
24 # - _bt_as_component_class_ptr: static method, convert the passed component class
25 # pointer to a 'bt_component_class *'.
28 class _ComponentClassConst(object._SharedObject
):
31 ptr
= self
._bt
_as
_component
_class
_ptr
(self
._ptr
)
32 name
= native_bt
.component_class_get_name(ptr
)
33 assert name
is not None
37 def description(self
):
38 ptr
= self
._bt
_as
_component
_class
_ptr
(self
._ptr
)
39 return native_bt
.component_class_get_description(ptr
)
43 ptr
= self
._bt
_as
_component
_class
_ptr
(self
._ptr
)
44 return native_bt
.component_class_get_help(ptr
)
46 def _bt_component_class_ptr(self
):
47 return self
._bt
_as
_component
_class
_ptr
(self
._ptr
)
49 def __eq__(self
, other
):
50 if not isinstance(other
, _ComponentClassConst
):
52 if not issubclass(other
, _UserComponent
):
57 return self
.addr
== other
.addr
60 class _SourceComponentClassConst(_ComponentClassConst
):
63 native_bt
.component_class_source_get_ref(ptr
)
67 native_bt
.component_class_source_put_ref(ptr
)
69 _bt_as_component_class_ptr
= staticmethod(
70 native_bt
.component_class_source_as_component_class
74 class _FilterComponentClassConst(_ComponentClassConst
):
77 native_bt
.component_class_filter_get_ref(ptr
)
81 native_bt
.component_class_filter_put_ref(ptr
)
83 _bt_as_component_class_ptr
= staticmethod(
84 native_bt
.component_class_filter_as_component_class
88 class _SinkComponentClassConst(_ComponentClassConst
):
91 native_bt
.component_class_sink_get_ref(ptr
)
95 native_bt
.component_class_sink_put_ref(ptr
)
97 _bt_as_component_class_ptr
= staticmethod(
98 native_bt
.component_class_sink_as_component_class
102 class _PortIterator(collections
.abc
.Iterator
):
103 def __init__(self
, comp_ports
):
104 self
._comp
_ports
= comp_ports
108 if self
._at
== len(self
._comp
_ports
):
111 comp_ports
= self
._comp
_ports
112 comp_ptr
= comp_ports
._component
_ptr
114 port_ptr
= comp_ports
._borrow
_port
_ptr
_at
_index
(comp_ptr
, self
._at
)
115 assert port_ptr
is not None
117 name
= native_bt
.port_get_name(comp_ports
._port
_pycls
._as
_port
_ptr
(port_ptr
))
118 assert name
is not None
124 class _ComponentPorts(collections
.abc
.Mapping
):
125 # component_ptr is a bt_component_source *, bt_component_filter * or
126 # bt_component_sink *. Its type must match the type expected by the
127 # functions passed as arguments.
132 borrow_port_ptr_by_name
,
133 borrow_port_ptr_at_index
,
137 self
._component
_ptr
= component_ptr
138 self
._borrow
_port
_ptr
_by
_name
= borrow_port_ptr_by_name
139 self
._borrow
_port
_ptr
_at
_index
= borrow_port_ptr_at_index
140 self
._get
_port
_count
= get_port_count
141 self
._port
_pycls
= port_pycls
143 def __getitem__(self
, key
):
144 utils
._check
_str
(key
)
145 port_ptr
= self
._borrow
_port
_ptr
_by
_name
(self
._component
_ptr
, key
)
150 return self
._port
_pycls
._create
_from
_ptr
_and
_get
_ref
(port_ptr
)
153 count
= self
._get
_port
_count
(self
._component
_ptr
)
158 return _PortIterator(self
)
161 # This class holds the methods which are common to both generic
162 # component objects and Python user component objects.
164 # Subclasses must provide these methods or property:
166 # - _bt_borrow_component_class_ptr: static method, must return a pointer to the
167 # specialized component class (e.g. 'bt_component_class_sink *') of the
168 # passed specialized component pointer (e.g. 'bt_component_sink *').
169 # - _bt_comp_cls_type: property, one of the native_bt.COMPONENT_CLASS_TYPE_*
171 # - _bt_as_component_ptr: static method, must return the passed specialized
172 # component pointer (e.g. 'bt_component_sink *') as a 'bt_component *'.
175 class _ComponentConst
:
178 ptr
= self
._bt
_as
_component
_ptr
(self
._ptr
)
179 name
= native_bt
.component_get_name(ptr
)
180 assert name
is not None
184 def logging_level(self
):
185 ptr
= self
._bt
_as
_component
_ptr
(self
._ptr
)
186 return native_bt
.component_get_logging_level(ptr
)
190 cc_ptr
= self
._bt
_borrow
_component
_class
_ptr
(self
._ptr
)
191 assert cc_ptr
is not None
192 return _create_component_class_from_const_ptr_and_get_ref(
193 cc_ptr
, self
._bt
_comp
_cls
_type
196 def __eq__(self
, other
):
197 if not hasattr(other
, "addr"):
200 return self
.addr
== other
.addr
203 class _SourceComponentConst(_ComponentConst
):
204 _bt_borrow_component_class_ptr
= staticmethod(
205 native_bt
.component_source_borrow_class_const
207 _bt_comp_cls_type
= native_bt
.COMPONENT_CLASS_TYPE_SOURCE
208 _bt_as_component_class_ptr
= staticmethod(
209 native_bt
.component_class_source_as_component_class
211 _bt_as_component_ptr
= staticmethod(native_bt
.component_source_as_component_const
)
214 class _FilterComponentConst(_ComponentConst
):
215 _bt_borrow_component_class_ptr
= staticmethod(
216 native_bt
.component_filter_borrow_class_const
218 _bt_comp_cls_type
= native_bt
.COMPONENT_CLASS_TYPE_FILTER
219 _bt_as_component_class_ptr
= staticmethod(
220 native_bt
.component_class_filter_as_component_class
222 _bt_as_component_ptr
= staticmethod(native_bt
.component_filter_as_component_const
)
225 class _SinkComponentConst(_ComponentConst
):
226 _bt_borrow_component_class_ptr
= staticmethod(
227 native_bt
.component_sink_borrow_class_const
229 _bt_comp_cls_type
= native_bt
.COMPONENT_CLASS_TYPE_SINK
230 _bt_as_component_class_ptr
= staticmethod(
231 native_bt
.component_class_sink_as_component_class
233 _bt_as_component_ptr
= staticmethod(native_bt
.component_sink_as_component_const
)
236 # This is analogous to _SourceComponentClassConst, but for source
238 class _GenericSourceComponentConst(object._SharedObject
, _SourceComponentConst
):
241 native_bt
.component_source_get_ref(ptr
)
245 native_bt
.component_source_put_ref(ptr
)
248 def output_ports(self
):
249 return _ComponentPorts(
251 native_bt
.component_source_borrow_output_port_by_name_const
,
252 native_bt
.component_source_borrow_output_port_by_index_const
,
253 native_bt
.component_source_get_output_port_count
,
254 bt2_port
._OutputPortConst
,
258 # This is analogous to _FilterComponentClassConst, but for filter
260 class _GenericFilterComponentConst(object._SharedObject
, _FilterComponentConst
):
263 native_bt
.component_filter_get_ref(ptr
)
267 native_bt
.component_filter_put_ref(ptr
)
270 def output_ports(self
):
271 return _ComponentPorts(
273 native_bt
.component_filter_borrow_output_port_by_name_const
,
274 native_bt
.component_filter_borrow_output_port_by_index_const
,
275 native_bt
.component_filter_get_output_port_count
,
276 bt2_port
._OutputPortConst
,
280 def input_ports(self
):
281 return _ComponentPorts(
283 native_bt
.component_filter_borrow_input_port_by_name_const
,
284 native_bt
.component_filter_borrow_input_port_by_index_const
,
285 native_bt
.component_filter_get_input_port_count
,
286 bt2_port
._InputPortConst
,
290 # This is analogous to _SinkComponentClassConst, but for sink
292 class _GenericSinkComponentConst(object._SharedObject
, _SinkComponentConst
):
295 native_bt
.component_sink_get_ref(ptr
)
299 native_bt
.component_sink_put_ref(ptr
)
302 def input_ports(self
):
303 return _ComponentPorts(
305 native_bt
.component_sink_borrow_input_port_by_name_const
,
306 native_bt
.component_sink_borrow_input_port_by_index_const
,
307 native_bt
.component_sink_get_input_port_count
,
308 bt2_port
._InputPortConst
,
312 _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS
= {
313 native_bt
.COMPONENT_CLASS_TYPE_SOURCE
: _GenericSourceComponentConst
,
314 native_bt
.COMPONENT_CLASS_TYPE_FILTER
: _GenericFilterComponentConst
,
315 native_bt
.COMPONENT_CLASS_TYPE_SINK
: _GenericSinkComponentConst
,
319 _COMP_CLS_TYPE_TO_GENERIC_COMP_CLS_PYCLS
= {
320 native_bt
.COMPONENT_CLASS_TYPE_SOURCE
: _SourceComponentClassConst
,
321 native_bt
.COMPONENT_CLASS_TYPE_FILTER
: _FilterComponentClassConst
,
322 native_bt
.COMPONENT_CLASS_TYPE_SINK
: _SinkComponentClassConst
,
326 # Create a component Python object of type _GenericSourceComponentConst,
327 # _GenericFilterComponentConst or _GenericSinkComponentConst, depending on
330 # Steals the reference to ptr from the caller.
333 def _create_component_from_const_ptr(ptr
, comp_cls_type
):
334 return _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS
[comp_cls_type
]._create
_from
_ptr
(ptr
)
337 # Same as the above, but acquire a new reference instead of stealing the
338 # reference from the caller.
341 def _create_component_from_const_ptr_and_get_ref(ptr
, comp_cls_type
):
342 return _COMP_CLS_TYPE_TO_GENERIC_COMP_PYCLS
[
344 ]._create
_from
_ptr
_and
_get
_ref
(ptr
)
347 # Create a component class Python object of type
348 # _SourceComponentClassConst, _FilterComponentClassConst or
349 # _SinkComponentClassConst, depending on comp_cls_type.
351 # Acquires a new reference to ptr.
354 def _create_component_class_from_const_ptr_and_get_ref(ptr
, comp_cls_type
):
355 return _COMP_CLS_TYPE_TO_GENERIC_COMP_CLS_PYCLS
[
357 ]._create
_from
_ptr
_and
_get
_ref
(ptr
)
360 def _trim_docstring(docstring
):
361 lines
= docstring
.expandtabs().splitlines()
369 for line
in lines
[1:]:
370 stripped
= line
.lstrip()
373 indent
= min(indent
, len(line
) - len(stripped
))
375 trimmed
= [lines
[0].strip()]
377 if indent
< sys
.maxsize
and len(lines
) > 1:
378 for line
in lines
[1:]:
379 trimmed
.append(line
[indent
:].rstrip())
381 while trimmed
and not trimmed
[-1]:
384 while trimmed
and not trimmed
[0]:
387 return "\n".join(trimmed
)
390 # Metaclass for component classes defined by Python code.
392 # The Python user can create a standard Python class which inherits one
393 # of the three base classes (_UserSourceComponent, _UserFilterComponent,
394 # or _UserSinkComponent). Those base classes set this class
395 # (_UserComponentType) as their metaclass.
397 # Once the body of a user-defined component class is executed, this
398 # metaclass is used to create and initialize the class. The metaclass
399 # creates a native BT component class of the corresponding type and
400 # associates it with this user-defined class. The metaclass also defines
401 # class methods like the `name` and `description` properties to match
402 # the _ComponentClassConst interface.
404 # The component class name which is used is either:
406 # * The `name` parameter of the class:
408 # class MySink(bt2.SinkComponent, name='my-custom-sink'):
411 # * If the `name` class parameter is not used: the name of the class
412 # itself (`MySink` in the example above).
414 # The component class description which is used is the user-defined
417 # class MySink(bt2.SinkComponent):
418 # 'Description goes here'
421 # A user-defined Python component class can have an __init__() method
422 # which must accept the following parameters:
424 # def __init__(self, config, params, obj):
427 # The value of the `obj` parameter is what was passed as the `obj`
428 # parameter if the component was instantiated from Python with
429 # Graph.add_component(). If the component was not instantiated from
430 # Python, is is always `None`.
432 # The user-defined component class can also have a _user_finalize()
433 # method (do NOT use __del__()) to be notified when the component object
436 # User-defined source and filter component classes must use the
437 # `message_iterator_class` class parameter to specify the
438 # message iterator class to use for this component class:
440 # class MyMessageIterator(bt2._UserMessageIterator):
443 # class MySource(bt2._UserSourceComponent,
444 # message_iterator_class=MyMessageIterator):
447 # This message iterator class must inherit bt2._UserMessageIterator.
448 # It can implement the __init__() method, which must accept the
449 # following parameters:
451 # def __init__(self, config, port):
454 # It can also implement the __next__() and _user_finalize() methods
455 # (again, do NOT use __del__()), which don't accept any parameters
458 # When the user-defined class is destroyed, this metaclass's __del__()
459 # method is called: the native BT component class pointer is put (not
460 # needed anymore, at least not by any Python code since all references
461 # are dropped for __del__() to be called).
462 class _UserComponentType(type):
463 # __new__() is used to catch custom class parameters
464 def __new__(meta_cls
, class_name
, bases
, attrs
, **kwargs
):
465 return super().__new
__(meta_cls
, class_name
, bases
, attrs
)
467 def __init__(cls
, class_name
, bases
, namespace
, **kwargs
):
468 super().__init
__(class_name
, bases
, namespace
)
470 # skip our own bases; they are never directly instantiated by the user
473 "_UserFilterSinkComponent",
474 "_UserSourceComponent",
475 "_UserFilterComponent",
476 "_UserSinkComponent",
479 if class_name
in own_bases
:
482 comp_cls_name
= kwargs
.get("name", class_name
)
483 utils
._check
_str
(comp_cls_name
)
484 comp_cls_descr
= None
487 if hasattr(cls
, "__doc__") and cls
.__doc
__ is not None:
488 utils
._check
_str
(cls
.__doc
__)
489 docstring
= _trim_docstring(cls
.__doc
__)
490 lines
= docstring
.splitlines()
493 comp_cls_descr
= lines
[0]
496 comp_cls_help
= "\n".join(lines
[2:])
498 iter_cls
= kwargs
.get("message_iterator_class")
500 if _UserSourceComponent
in bases
:
501 _UserComponentType
._bt
_set
_iterator
_class
(cls
, iter_cls
)
502 cc_ptr
= native_bt
.bt2_component_class_source_create(
503 cls
, comp_cls_name
, comp_cls_descr
, comp_cls_help
505 elif _UserFilterComponent
in bases
:
506 _UserComponentType
._bt
_set
_iterator
_class
(cls
, iter_cls
)
507 cc_ptr
= native_bt
.bt2_component_class_filter_create(
508 cls
, comp_cls_name
, comp_cls_descr
, comp_cls_help
510 elif _UserSinkComponent
in bases
:
511 if not hasattr(cls
, "_user_consume"):
512 raise bt2
._IncompleteUserClass(
513 "cannot create component class '{}': missing a _user_consume() method".format(
518 cc_ptr
= native_bt
.bt2_component_class_sink_create(
519 cls
, comp_cls_name
, comp_cls_descr
, comp_cls_help
522 raise bt2
._IncompleteUserClass(
523 "cannot find a known component class base in the bases of '{}'".format(
529 raise bt2
._MemoryError(
530 "cannot create component class '{}'".format(class_name
)
533 cls
._bt
_cc
_ptr
= cc_ptr
535 def _bt_init_from_native(cls
, comp_ptr
, params_ptr
, obj
):
536 # create instance, not user-initialized yet
537 self
= cls
.__new
__(cls
)
540 config
= cls
._config
_pycls
()
542 # pointer to native self component object (weak/borrowed)
543 self
._bt
_ptr
= comp_ptr
545 # call user's __init__() method
546 if params_ptr
is not None:
547 params
= bt2_value
._create
_from
_const
_ptr
_and
_get
_ref
(params_ptr
)
551 self
.__init
__(config
, params
, obj
)
554 def __call__(cls
, *args
, **kwargs
):
556 "cannot directly instantiate a user component from a Python module"
560 def _bt_set_iterator_class(cls
, iter_cls
):
562 raise bt2
._IncompleteUserClass(
563 "cannot create component class '{}': missing message iterator class".format(
568 if not issubclass(iter_cls
, bt2_message_iterator
._UserMessageIterator
):
569 raise bt2
._IncompleteUserClass(
570 "cannot create component class '{}': message iterator class does not inherit bt2._UserMessageIterator".format(
575 if not hasattr(iter_cls
, "__next__"):
576 raise bt2
._IncompleteUserClass(
577 "cannot create component class '{}': message iterator class is missing a __next__() method".format(
582 if hasattr(iter_cls
, "_user_can_seek_ns_from_origin") and not hasattr(
583 iter_cls
, "_user_seek_ns_from_origin"
585 raise bt2
._IncompleteUserClass(
586 "cannot create component class '{}': message iterator class implements _user_can_seek_ns_from_origin but not _user_seek_ns_from_origin".format(
591 if hasattr(iter_cls
, "_user_can_seek_beginning") and not hasattr(
592 iter_cls
, "_user_seek_beginning"
594 raise bt2
._IncompleteUserClass(
595 "cannot create component class '{}': message iterator class implements _user_can_seek_beginning but not _user_seek_beginning".format(
600 cls
._iter
_cls
= iter_cls
604 ptr
= cls
._bt
_as
_component
_class
_ptr
(cls
._bt
_cc
_ptr
)
605 return native_bt
.component_class_get_name(ptr
)
608 def description(cls
):
609 ptr
= cls
._bt
_as
_component
_class
_ptr
(cls
._bt
_cc
_ptr
)
610 return native_bt
.component_class_get_description(ptr
)
614 ptr
= cls
._bt
_as
_component
_class
_ptr
(cls
._bt
_cc
_ptr
)
615 return native_bt
.component_class_get_help(ptr
)
619 return int(cls
._bt
_cc
_ptr
)
621 def _bt_get_supported_mip_versions_from_native(cls
, params_ptr
, obj
, log_level
):
622 # this can raise, but the native side checks the exception
623 if params_ptr
is not None:
624 params
= bt2_value
._create
_from
_const
_ptr
_and
_get
_ref
(params_ptr
)
628 # this can raise, but the native side checks the exception
629 range_set
= cls
._user
_get
_supported
_mip
_versions
(params
, obj
, log_level
)
631 if type(range_set
) is not bt2
.UnsignedIntegerRangeSet
:
632 # this can raise, but the native side checks the exception
633 range_set
= bt2
.UnsignedIntegerRangeSet(range_set
)
635 # return new reference
636 range_set
._get
_ref
(range_set
._ptr
)
637 return int(range_set
._ptr
)
639 def _user_get_supported_mip_versions(cls
, params
, obj
, log_level
):
642 def _bt_query_from_native(
643 cls
, priv_query_exec_ptr
, object_name
, params_ptr
, method_obj
645 # this can raise, but the native side checks the exception
646 if params_ptr
is not None:
647 params
= bt2_value
._create
_from
_const
_ptr
_and
_get
_ref
(params_ptr
)
651 priv_query_exec
= bt2_query_executor
._PrivateQueryExecutor
(priv_query_exec_ptr
)
654 # this can raise, but the native side checks the exception
655 results
= cls
._user
_query
(priv_query_exec
, object_name
, params
, method_obj
)
657 # the private query executor is a private view on the query
658 # executor; it's not a shared object (the library does not
659 # offer an API to get/put a reference, just like "self"
660 # objects) from this query's point of view, so invalidate
661 # the object in case the user kept a reference and uses it
663 priv_query_exec
._invalidate
()
665 # this can raise, but the native side checks the exception
666 results
= bt2
.create_value(results
)
669 results_ptr
= native_bt
.value_null
671 results_ptr
= results
._ptr
673 # return new reference
674 bt2_value
._Value
._get
_ref
(results_ptr
)
675 return int(results_ptr
)
677 def _user_query(cls
, priv_query_executor
, object_name
, params
, method_obj
):
678 raise bt2
.UnknownObject
680 def _bt_component_class_ptr(self
):
681 return self
._bt
_as
_component
_class
_ptr
(self
._bt
_cc
_ptr
)
684 if hasattr(cls
, "_bt_cc_ptr"):
685 cc_ptr
= cls
._bt
_as
_component
_class
_ptr
(cls
._bt
_cc
_ptr
)
686 native_bt
.component_class_put_ref(cc_ptr
)
687 native_bt
.bt2_unregister_cc_ptr_to_py_cls(cc_ptr
)
690 # Configuration objects for components.
692 # These are passed in __init__ to allow components to change some configuration
693 # parameters during initialization and not after. As you can see, they are not
694 # used at the moment, but are there in case we want to add such parameters.
697 class _UserComponentConfiguration
:
701 class _UserSourceComponentConfiguration(_UserComponentConfiguration
):
705 class _UserFilterComponentConfiguration(_UserComponentConfiguration
):
709 class _UserSinkComponentConfiguration(_UserComponentConfiguration
):
713 # Subclasses must provide these methods or property:
715 # - _bt_as_not_self_specific_component_ptr: static method, must return the passed
716 # specialized self component pointer (e.g. 'bt_self_component_sink *') as a
717 # specialized non-self pointer (e.g. 'bt_component_sink *').
718 # - _bt_borrow_component_class_ptr: static method, must return a pointer to the
719 # specialized component class (e.g. 'bt_component_class_sink *') of the
720 # passed specialized component pointer (e.g. 'bt_component_sink *').
721 # - _bt_comp_cls_type: property, one of the native_bt.COMPONENT_CLASS_TYPE_*
725 class _UserComponent(metaclass
=_UserComponentType
):
728 ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self
._bt
_ptr
)
729 ptr
= self
._bt
_as
_component
_ptr
(ptr
)
730 name
= native_bt
.component_get_name(ptr
)
731 assert name
is not None
735 def logging_level(self
):
736 ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self
._bt
_ptr
)
737 ptr
= self
._bt
_as
_component
_ptr
(ptr
)
738 return native_bt
.component_get_logging_level(ptr
)
742 comp_ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self
._bt
_ptr
)
743 cc_ptr
= self
._bt
_borrow
_component
_class
_ptr
(comp_ptr
)
744 return _create_component_class_from_const_ptr_and_get_ref(
745 cc_ptr
, self
._bt
_comp
_cls
_type
750 return int(self
._bt
_ptr
)
753 def _graph_mip_version(self
):
754 ptr
= self
._bt
_as
_self
_component
_ptr
(self
._bt
_ptr
)
755 return native_bt
.self_component_get_graph_mip_version(ptr
)
757 def __init__(self
, config
, params
, obj
):
760 def _user_finalize(self
):
763 def _user_port_connected(self
, port
, other_port
):
766 def _bt_port_connected_from_native(
767 self
, self_port_ptr
, self_port_type
, other_port_ptr
769 port
= bt2_port
._create
_self
_from
_ptr
_and
_get
_ref
(self_port_ptr
, self_port_type
)
771 if self_port_type
== native_bt
.PORT_TYPE_OUTPUT
:
772 other_port_type
= native_bt
.PORT_TYPE_INPUT
774 other_port_type
= native_bt
.PORT_TYPE_OUTPUT
776 other_port
= bt2_port
._create
_from
_const
_ptr
_and
_get
_ref
(
777 other_port_ptr
, other_port_type
779 self
._user
_port
_connected
(port
, other_port
)
781 def _create_trace_class(
782 self
, user_attributes
=None, assigns_automatic_stream_class_id
=True
784 ptr
= self
._bt
_as
_self
_component
_ptr
(self
._bt
_ptr
)
785 tc_ptr
= native_bt
.trace_class_create(ptr
)
788 raise bt2
._MemoryError("could not create trace class")
790 tc
= bt2_trace_class
._TraceClass
._create
_from
_ptr
(tc_ptr
)
791 tc
._assigns
_automatic
_stream
_class
_id
= assigns_automatic_stream_class_id
793 if user_attributes
is not None:
794 tc
._user
_attributes
= user_attributes
798 def _create_clock_class(
802 user_attributes
=None,
806 origin_is_unix_epoch
=True,
809 ptr
= self
._bt
_as
_self
_component
_ptr
(self
._bt
_ptr
)
810 cc_ptr
= native_bt
.clock_class_create(ptr
)
813 raise bt2
._MemoryError("could not create clock class")
815 cc
= bt2_clock_class
._ClockClass
._create
_from
_ptr
(cc_ptr
)
817 if frequency
is not None:
818 cc
._frequency
= frequency
823 if user_attributes
is not None:
824 cc
._user
_attributes
= user_attributes
826 if description
is not None:
827 cc
._description
= description
829 if precision
is not None:
830 cc
._precision
= precision
832 if offset
is not None:
835 cc
._origin
_is
_unix
_epoch
= origin_is_unix_epoch
843 class _UserSourceComponent(_UserComponent
, _SourceComponentConst
):
844 _bt_as_not_self_specific_component_ptr
= staticmethod(
845 native_bt
.self_component_source_as_component_source
847 _bt_as_self_component_ptr
= staticmethod(
848 native_bt
.self_component_source_as_self_component
850 _config_pycls
= _UserSourceComponentConfiguration
853 def _output_ports(self
):
854 def get_output_port_count(self_ptr
):
855 ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self_ptr
)
856 return native_bt
.component_source_get_output_port_count(ptr
)
858 return _ComponentPorts(
860 native_bt
.self_component_source_borrow_output_port_by_name
,
861 native_bt
.self_component_source_borrow_output_port_by_index
,
862 get_output_port_count
,
863 bt2_port
._UserComponentOutputPort
,
866 def _add_output_port(self
, name
, user_data
=None):
867 utils
._check
_str
(name
)
869 if name
in self
._output
_ports
:
871 "source component `{}` already contains an output port named `{}`".format(
876 fn
= native_bt
.self_component_source_add_output_port
877 comp_status
, self_port_ptr
= fn(self
._bt
_ptr
, name
, user_data
)
878 utils
._handle
_func
_status
(
879 comp_status
, "cannot add output port to source component object"
881 assert self_port_ptr
is not None
882 return bt2_port
._UserComponentOutputPort
._create
_from
_ptr
_and
_get
_ref
(
887 class _UserFilterComponent(_UserComponent
, _FilterComponentConst
):
888 _bt_as_not_self_specific_component_ptr
= staticmethod(
889 native_bt
.self_component_filter_as_component_filter
891 _bt_as_self_component_ptr
= staticmethod(
892 native_bt
.self_component_filter_as_self_component
894 _config_pycls
= _UserFilterComponentConfiguration
897 def _output_ports(self
):
898 def get_output_port_count(self_ptr
):
899 ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self_ptr
)
900 return native_bt
.component_filter_get_output_port_count(ptr
)
902 return _ComponentPorts(
904 native_bt
.self_component_filter_borrow_output_port_by_name
,
905 native_bt
.self_component_filter_borrow_output_port_by_index
,
906 get_output_port_count
,
907 bt2_port
._UserComponentOutputPort
,
911 def _input_ports(self
):
912 def get_input_port_count(self_ptr
):
913 ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self_ptr
)
914 return native_bt
.component_filter_get_input_port_count(ptr
)
916 return _ComponentPorts(
918 native_bt
.self_component_filter_borrow_input_port_by_name
,
919 native_bt
.self_component_filter_borrow_input_port_by_index
,
920 get_input_port_count
,
921 bt2_port
._UserComponentInputPort
,
924 def _add_output_port(self
, name
, user_data
=None):
925 utils
._check
_str
(name
)
927 if name
in self
._output
_ports
:
929 "filter component `{}` already contains an output port named `{}`".format(
934 fn
= native_bt
.self_component_filter_add_output_port
935 comp_status
, self_port_ptr
= fn(self
._bt
_ptr
, name
, user_data
)
936 utils
._handle
_func
_status
(
937 comp_status
, "cannot add output port to filter component object"
940 return bt2_port
._UserComponentOutputPort
._create
_from
_ptr
_and
_get
_ref
(
944 def _add_input_port(self
, name
, user_data
=None):
945 utils
._check
_str
(name
)
947 if name
in self
._input
_ports
:
949 "filter component `{}` already contains an input port named `{}`".format(
954 fn
= native_bt
.self_component_filter_add_input_port
955 comp_status
, self_port_ptr
= fn(self
._bt
_ptr
, name
, user_data
)
956 utils
._handle
_func
_status
(
957 comp_status
, "cannot add input port to filter component object"
960 return bt2_port
._UserComponentInputPort
._create
_from
_ptr
_and
_get
_ref
(
965 class _UserSinkComponent(_UserComponent
, _SinkComponentConst
):
966 _bt_as_not_self_specific_component_ptr
= staticmethod(
967 native_bt
.self_component_sink_as_component_sink
969 _bt_as_self_component_ptr
= staticmethod(
970 native_bt
.self_component_sink_as_self_component
972 _config_pycls
= _UserSinkComponentConfiguration
974 def _bt_graph_is_configured_from_native(self
):
975 self
._user
_graph
_is
_configured
()
977 def _user_graph_is_configured(self
):
981 def _input_ports(self
):
982 def get_input_port_count(self_ptr
):
983 ptr
= self
._bt
_as
_not
_self
_specific
_component
_ptr
(self_ptr
)
984 return native_bt
.component_sink_get_input_port_count(ptr
)
986 return _ComponentPorts(
988 native_bt
.self_component_sink_borrow_input_port_by_name
,
989 native_bt
.self_component_sink_borrow_input_port_by_index
,
990 get_input_port_count
,
991 bt2_port
._UserComponentInputPort
,
994 def _add_input_port(self
, name
, user_data
=None):
995 utils
._check
_str
(name
)
997 if name
in self
._input
_ports
:
999 "sink component `{}` already contains an input port named `{}`".format(
1004 fn
= native_bt
.self_component_sink_add_input_port
1005 comp_status
, self_port_ptr
= fn(self
._bt
_ptr
, name
, user_data
)
1006 utils
._handle
_func
_status
(
1007 comp_status
, "cannot add input port to sink component object"
1009 assert self_port_ptr
1010 return bt2_port
._UserComponentInputPort
._create
_from
_ptr
_and
_get
_ref
(
1014 def _create_message_iterator(self
, input_port
):
1015 utils
._check
_type
(input_port
, bt2_port
._UserComponentInputPort
)
1017 if not input_port
.is_connected
:
1018 raise ValueError("input port is not connected")
1023 ) = native_bt
.bt2_message_iterator_create_from_sink_component(
1024 self
._bt
_ptr
, input_port
._ptr
1026 utils
._handle
_func
_status
(status
, "cannot create message iterator object")
1027 assert msg_iter_ptr
is not None
1029 return bt2_message_iterator
._UserComponentInputPortMessageIterator
(msg_iter_ptr
)
1032 def _is_interrupted(self
):
1033 return bool(native_bt
.self_component_sink_is_interrupted(self
._bt
_ptr
))