src/bindings/python/bt2/bt2/graph.py

   1 # The MIT License (MIT)
   2 #
   3 # Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
   4 #
   5 # Permission is hereby granted, free of charge, to any person obtaining a copy
   6 # of this software and associated documentation files (the "Software"), to deal
   7 # in the Software without restriction, including without limitation the rights
   8 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 # copies of the Software, and to permit persons to whom the Software is
  10 # furnished to do so, subject to the following conditions:
  11 #
  12 # The above copyright notice and this permission notice shall be included in
  13 # all copies or substantial portions of the Software.
  14 #
  15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 # THE SOFTWARE.
  22
  23 from bt2 import native_bt, object, utils
  24 from bt2 import interrupter as bt2_interrupter
  25 from bt2 import connection as bt2_connection
  26 from bt2 import component as bt2_component
  27 import functools
  28 from bt2 import port as bt2_port
  29 from bt2 import logging as bt2_logging
  30 import bt2
  31
  32
  33 def _graph_port_added_listener_from_native(
  34     user_listener, component_ptr, component_type, port_ptr, port_type
  35 ):
  36     component = bt2_component._create_component_from_const_ptr_and_get_ref(
  37         component_ptr, component_type
  38     )
  39     port = bt2_port._create_from_const_ptr_and_get_ref(port_ptr, port_type)
  40     user_listener(component, port)
  41
  42
  43 class Graph(object._SharedObject):
  44     _get_ref = staticmethod(native_bt.graph_get_ref)
  45     _put_ref = staticmethod(native_bt.graph_put_ref)
  46
  47     def __init__(self, mip_version=0):
  48         utils._check_uint64(mip_version)
  49
  50         if mip_version > bt2.get_maximal_mip_version():
  51             raise ValueError('unknown MIP version {}'.format(mip_version))
  52
  53         ptr = native_bt.graph_create(mip_version)
  54
  55         if ptr is None:
  56             raise bt2._MemoryError('cannot create graph object')
  57
  58         super().__init__(ptr)
  59
  60         # list of listener partials to keep a reference as long as
  61         # this graph exists
  62         self._listener_partials = []
  63
  64     def add_component(
  65         self,
  66         component_class,
  67         name,
  68         params=None,
  69         obj=None,
  70         logging_level=bt2_logging.LoggingLevel.NONE,
  71     ):
  72         if isinstance(component_class, bt2_component._SourceComponentClassConst):
  73             cc_ptr = component_class._ptr
  74             add_fn = native_bt.bt2_graph_add_source_component
  75             cc_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE
  76         elif isinstance(component_class, bt2_component._FilterComponentClassConst):
  77             cc_ptr = component_class._ptr
  78             add_fn = native_bt.bt2_graph_add_filter_component
  79             cc_type = native_bt.COMPONENT_CLASS_TYPE_FILTER
  80         elif isinstance(component_class, bt2_component._SinkComponentClassConst):
  81             cc_ptr = component_class._ptr
  82             add_fn = native_bt.bt2_graph_add_sink_component
  83             cc_type = native_bt.COMPONENT_CLASS_TYPE_SINK
  84         elif issubclass(component_class, bt2_component._UserSourceComponent):
  85             cc_ptr = component_class._bt_cc_ptr
  86             add_fn = native_bt.bt2_graph_add_source_component
  87             cc_type = native_bt.COMPONENT_CLASS_TYPE_SOURCE
  88         elif issubclass(component_class, bt2_component._UserSinkComponent):
  89             cc_ptr = component_class._bt_cc_ptr
  90             add_fn = native_bt.bt2_graph_add_sink_component
  91             cc_type = native_bt.COMPONENT_CLASS_TYPE_SINK
  92         elif issubclass(component_class, bt2_component._UserFilterComponent):
  93             cc_ptr = component_class._bt_cc_ptr
  94             add_fn = native_bt.bt2_graph_add_filter_component
  95             cc_type = native_bt.COMPONENT_CLASS_TYPE_FILTER
  96         else:
  97             raise TypeError(
  98                 "'{}' is not a component class".format(
  99                     component_class.__class__.__name__
 100                 )
 101             )
 102
 103         utils._check_str(name)
 104         utils._check_log_level(logging_level)
 105         base_cc_ptr = component_class._bt_component_class_ptr()
 106
 107         if obj is not None and not native_bt.bt2_is_python_component_class(base_cc_ptr):
 108             raise ValueError('cannot pass a Python object to a non-Python component')
 109
 110         if params is not None and not isinstance(params, (dict, bt2.MapValue)):
 111             raise TypeError("'params' parameter is not a 'dict' or a 'bt2.MapValue'.")
 112
 113         params = bt2.create_value(params)
 114
 115         params_ptr = params._ptr if params is not None else None
 116
 117         status, comp_ptr = add_fn(
 118             self._ptr, cc_ptr, name, params_ptr, obj, logging_level
 119         )
 120         utils._handle_func_status(status, 'cannot add component to graph')
 121         assert comp_ptr
 122         return bt2_component._create_component_from_const_ptr(comp_ptr, cc_type)
 123
 124     def connect_ports(self, upstream_port, downstream_port):
 125         utils._check_type(upstream_port, bt2_port._OutputPortConst)
 126         utils._check_type(downstream_port, bt2_port._InputPortConst)
 127         status, conn_ptr = native_bt.graph_connect_ports(
 128             self._ptr, upstream_port._ptr, downstream_port._ptr
 129         )
 130         utils._handle_func_status(status, 'cannot connect component ports within graph')
 131         assert conn_ptr
 132         return bt2_connection._ConnectionConst._create_from_ptr(conn_ptr)
 133
 134     def add_port_added_listener(self, listener):
 135         if not callable(listener):
 136             raise TypeError("'listener' parameter is not callable")
 137
 138         fn = native_bt.bt2_graph_add_port_added_listener
 139         listener_from_native = functools.partial(
 140             _graph_port_added_listener_from_native, listener
 141         )
 142
 143         listener_ids = fn(self._ptr, listener_from_native)
 144         if listener_ids is None:
 145             raise bt2._Error('cannot add listener to graph object')
 146
 147         # keep the partial's reference
 148         self._listener_partials.append(listener_from_native)
 149
 150     def run_once(self):
 151         status = native_bt.graph_run_once(self._ptr)
 152         utils._handle_func_status(status, 'graph object could not run once')
 153
 154     def run(self):
 155         status = native_bt.graph_run(self._ptr)
 156         utils._handle_func_status(status, 'graph object stopped running')
 157
 158     def add_interrupter(self, interrupter):
 159         utils._check_type(interrupter, bt2_interrupter.Interrupter)
 160         native_bt.graph_add_interrupter(self._ptr, interrupter._ptr)
 161
 162     def interrupt(self):
 163         native_bt.graph_interrupt(self._ptr)