from bt2 import clock_class as bt2_clock_class
from bt2 import query_executor as bt2_query_executor
from bt2 import port as bt2_port
+from bt2 import error as bt2_error
+from bt2 import integer_range_set as bt2_integer_range_set
import sys
-import bt2
class _IncompleteUserClass(Exception):
)
elif _UserSinkComponent in bases:
if not hasattr(cls, "_user_consume"):
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot create component class '{}': missing a _user_consume() method".format(
class_name
)
cls, comp_cls_name, comp_cls_descr, comp_cls_help
)
else:
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot find a known component class base in the bases of '{}'".format(
class_name
)
)
if cc_ptr is None:
- raise bt2._MemoryError(
+ raise bt2_error._MemoryError(
"cannot create component class '{}'".format(class_name)
)
@staticmethod
def _bt_set_iterator_class(cls, iter_cls):
if iter_cls is None:
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot create component class '{}': missing message iterator class".format(
cls.__name__
)
)
if not issubclass(iter_cls, bt2_message_iterator._UserMessageIterator):
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot create component class '{}': message iterator class does not inherit bt2._UserMessageIterator".format(
cls.__name__
)
)
if not hasattr(iter_cls, "__next__"):
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot create component class '{}': message iterator class is missing a __next__() method".format(
cls.__name__
)
if hasattr(iter_cls, "_user_can_seek_ns_from_origin") and not hasattr(
iter_cls, "_user_seek_ns_from_origin"
):
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot create component class '{}': message iterator class implements _user_can_seek_ns_from_origin but not _user_seek_ns_from_origin".format(
cls.__name__
)
if hasattr(iter_cls, "_user_can_seek_beginning") and not hasattr(
iter_cls, "_user_seek_beginning"
):
- raise bt2._IncompleteUserClass(
+ raise _IncompleteUserClass(
"cannot create component class '{}': message iterator class implements _user_can_seek_beginning but not _user_seek_beginning".format(
cls.__name__
)
# this can raise, but the native side checks the exception
range_set = cls._user_get_supported_mip_versions(params, obj, log_level)
- if type(range_set) is not bt2.UnsignedIntegerRangeSet:
+ if type(range_set) is not bt2_integer_range_set.UnsignedIntegerRangeSet:
# this can raise, but the native side checks the exception
- range_set = bt2.UnsignedIntegerRangeSet(range_set)
+ range_set = bt2_integer_range_set.UnsignedIntegerRangeSet(range_set)
# return new reference
range_set._get_ref(range_set._ptr)
priv_query_exec._invalidate()
# this can raise, but the native side checks the exception
- results = bt2.create_value(results)
+ results = bt2_value.create_value(results)
if results is None:
results_ptr = native_bt.value_null
return int(results_ptr)
def _user_query(cls, priv_query_executor, object_name, params, method_obj):
- raise bt2.UnknownObject
+ raise bt2_utils.UnknownObject
def _bt_component_class_ptr(self):
return self._bt_as_component_class_ptr(self._bt_cc_ptr)
tc_ptr = native_bt.trace_class_create(ptr)
if tc_ptr is None:
- raise bt2._MemoryError("could not create trace class")
+ raise bt2_error._MemoryError("could not create trace class")
tc = bt2_trace_class._TraceClass._create_from_ptr(tc_ptr)
tc._assigns_automatic_stream_class_id = assigns_automatic_stream_class_id
cc_ptr = native_bt.clock_class_create(ptr)
if cc_ptr is None:
- raise bt2._MemoryError("could not create clock class")
+ raise bt2_error._MemoryError("could not create clock class")
cc = bt2_clock_class._ClockClass._create_from_ptr(cc_ptr)
from bt2 import native_bt
from bt2 import component as bt2_component
-import bt2
+from bt2 import value as bt2_value
def _is_source_comp_cls(comp_cls):
raise ValueError("cannot pass a Python object to a non-Python component")
self._comp_cls = component_class
- self._params = bt2.create_value(params)
+ self._params = bt2_value.create_value(params)
self._obj = obj
@property
import collections.abc
from bt2 import field_path as bt2_field_path
from bt2 import integer_range_set as bt2_integer_range_set
+from bt2 import error as bt2_error
from bt2 import value as bt2_value
-import bt2
def _obj_type_from_field_class_ptr_template(type_map, ptr):
def _check_create_status(self, ptr):
if ptr is None:
- raise bt2._MemoryError(
+ raise bt2_error._MemoryError(
"cannot create {} field class object".format(self._NAME.lower())
)
if user_attributes is not None:
# check now that user attributes are valid
- user_attributes_value = bt2.create_value(user_attributes)
+ user_attributes_value = bt2_value.create_value(user_attributes)
status = native_bt.field_class_structure_append_member(
self._ptr, name, field_class._ptr
if user_attributes is not None:
# check now that user attributes are valid
- user_attributes_value = bt2.create_value(user_attributes)
+ user_attributes_value = bt2_value.create_value(user_attributes)
status = native_bt.field_class_variant_without_selector_append_option(
self._ptr, name, field_class._ptr
if user_attributes is not None:
# check now that user attributes are valid
- user_attributes_value = bt2.create_value(user_attributes)
+ user_attributes_value = bt2_value.create_value(user_attributes)
# TODO: check overlaps (precondition of self._append_option())
import functools
from bt2 import port as bt2_port
from bt2 import logging as bt2_logging
-import bt2
+from bt2 import mip as bt2_mip
+from bt2 import error as bt2_error
+from bt2 import value as bt2_value
def _graph_port_added_listener_from_native(
def __init__(self, mip_version=0):
bt2_utils._check_uint64(mip_version)
- if mip_version > bt2.get_maximal_mip_version():
+ if mip_version > bt2_mip.get_maximal_mip_version():
raise ValueError("unknown MIP version {}".format(mip_version))
ptr = native_bt.graph_create(mip_version)
if ptr is None:
- raise bt2._MemoryError("cannot create graph object")
+ raise bt2_error._MemoryError("cannot create graph object")
super().__init__(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)):
+ if params is not None and not isinstance(params, (dict, bt2_value.MapValue)):
raise TypeError("'params' parameter is not a 'dict' or a 'bt2.MapValue'.")
- params = bt2.create_value(params)
+ params = bt2_value.create_value(params)
params_ptr = params._ptr if params is not None else None
listener_ids = fn(self._ptr, listener_from_native)
if listener_ids is None:
- raise bt2._Error("cannot add listener to graph object")
+ raise bt2_error._Error("cannot add listener to graph object")
# keep the partial's reference
self._listener_partials.append(listener_from_native)
from bt2 import native_bt
from bt2 import object as bt2_object
from bt2 import utils as bt2_utils
+from bt2 import error as bt2_error
import collections.abc
-import bt2
class _IntegerRangeConst:
ptr = self._create_range_set()
if ptr is None:
- raise bt2._MemoryError("cannot create range set object")
+ raise bt2_error._MemoryError("cannot create range set object")
super().__init__(ptr)
from bt2 import native_bt
from bt2 import object as bt2_object
-import bt2
+from bt2 import error as bt2_error
class Interrupter(bt2_object._SharedObject):
ptr = native_bt.interrupter_create()
if ptr is None:
- raise bt2._MemoryError("cannot create interrupter object")
+ raise bt2_error._MemoryError("cannot create interrupter object")
super().__init__(ptr)
from bt2 import packet as bt2_packet
from bt2 import port as bt2_port
from bt2 import clock_class as bt2_clock_class
-import bt2
+from bt2 import error as bt2_error
class _MessageIterator(collections.abc.Iterator):
pass
def __next__(self):
- raise bt2.Stop
+ raise bt2_utils.Stop
def _bt_next_from_native(self):
# this can raise anything: it's catched by the native part
try:
msg = next(self)
except StopIteration:
- raise bt2.Stop
+ raise bt2_utils.Stop
except Exception:
raise
)
if ptr is None:
- raise bt2._MemoryError("cannot create event message object")
+ raise bt2_error._MemoryError("cannot create event message object")
return bt2_message._EventMessage(ptr)
)
if ptr is None:
- raise bt2._MemoryError("cannot create inactivity message object")
+ raise bt2_error._MemoryError("cannot create inactivity message object")
return bt2_message._MessageIteratorInactivityMessage(ptr)
ptr = native_bt.message_stream_beginning_create(self._bt_ptr, stream._ptr)
if ptr is None:
- raise bt2._MemoryError("cannot create stream beginning message object")
+ raise bt2_error._MemoryError(
+ "cannot create stream beginning message object"
+ )
msg = bt2_message._StreamBeginningMessage(ptr)
ptr = native_bt.message_stream_end_create(self._bt_ptr, stream._ptr)
if ptr is None:
- raise bt2._MemoryError("cannot create stream end message object")
+ raise bt2_error._MemoryError("cannot create stream end message object")
msg = bt2_message._StreamEndMessage(ptr)
ptr = native_bt.message_packet_beginning_create(self._bt_ptr, packet._ptr)
if ptr is None:
- raise bt2._MemoryError("cannot create packet beginning message object")
+ raise bt2_error._MemoryError(
+ "cannot create packet beginning message object"
+ )
return bt2_message._PacketBeginningMessage(ptr)
ptr = native_bt.message_packet_end_create(self._bt_ptr, packet._ptr)
if ptr is None:
- raise bt2._MemoryError("cannot create packet end message object")
+ raise bt2_error._MemoryError("cannot create packet end message object")
return bt2_message._PacketEndMessage(ptr)
ptr = native_bt.message_discarded_events_create(self._bt_ptr, stream._ptr)
if ptr is None:
- raise bt2._MemoryError("cannot discarded events message object")
+ raise bt2_error._MemoryError("cannot discarded events message object")
msg = bt2_message._DiscardedEventsMessage(ptr)
ptr = native_bt.message_discarded_packets_create(self._bt_ptr, stream._ptr)
if ptr is None:
- raise bt2._MemoryError("cannot discarded packets message object")
+ raise bt2_error._MemoryError("cannot discarded packets message object")
msg = bt2_message._DiscardedPacketsMessage(ptr)
from bt2 import native_bt
from bt2 import utils as bt2_utils
-import bt2
+from bt2 import error as bt2_error
+from bt2 import logging as bt2_logging
+from bt2 import component_descriptor as bt2_component_descriptor
def get_greatest_operative_mip_version(
- component_descriptors, log_level=bt2.LoggingLevel.NONE
+ component_descriptors, log_level=bt2_logging.LoggingLevel.NONE
):
bt2_utils._check_log_level(log_level)
comp_descr_set_ptr = native_bt.component_descriptor_set_create()
if comp_descr_set_ptr is None:
- raise bt2._MemoryError("cannot create component descriptor set object")
+ raise bt2_error._MemoryError("cannot create component descriptor set object")
if len(component_descriptors) == 0:
raise ValueError("no component descriptors")
try:
for descr in component_descriptors:
- if type(descr) is not bt2.ComponentDescriptor:
+ if type(descr) is not bt2_component_descriptor.ComponentDescriptor:
raise TypeError("'{}' is not a component descriptor".format(descr))
base_cc_ptr = descr.component_class._bt_component_class_ptr()
from bt2 import utils as bt2_utils
from bt2 import interrupter as bt2_interrupter
from bt2 import value as bt2_value
-import bt2
+from bt2 import error as bt2_error
def _bt2_component():
if params is None:
params_ptr = native_bt.value_null
else:
- params = bt2.create_value(params)
+ params = bt2_value.create_value(params)
params_ptr = params._ptr
cc_ptr = component_class._bt_component_class_ptr()
)
if ptr is None:
- raise bt2._MemoryError("cannot create query executor object")
+ raise bt2_error._MemoryError("cannot create query executor object")
super().__init__(ptr)
from bt2 import packet as bt2_packet
from bt2 import stream_class as bt2_stream_class
from bt2 import value as bt2_value
-import bt2
+from bt2 import error as bt2_error
def _bt2_trace():
packet_ptr = native_bt.packet_create(self._ptr)
if packet_ptr is None:
- raise bt2._MemoryError("cannot create packet object")
+ raise bt2_error._MemoryError("cannot create packet object")
return bt2_packet._Packet._create_from_ptr(packet_ptr)
from bt2 import value as bt2_value
from bt2 import stream as bt2_stream
from bt2 import stream_class as bt2_stream_class
-import bt2
+from bt2 import error as bt2_error
+
import functools
import uuid as uuidp
)
if stream_ptr is None:
- raise bt2._MemoryError("cannot create stream object")
+ raise bt2_error._MemoryError("cannot create stream object")
stream = bt2_stream._Stream._create_from_ptr(stream_ptr)
from bt2 import field_class as bt2_field_class
from bt2 import integer_range_set as bt2_integer_range_set
from bt2 import trace as bt2_trace
+from bt2 import error as bt2_error
from bt2 import value as bt2_value
import collections.abc
import functools
-import bt2
def _trace_class_destruction_listener_from_native(
trace_ptr = native_bt.trace_create(self._ptr)
if trace_ptr is None:
- raise bt2._MemoryError("cannot create trace class object")
+ raise bt2_error._MemoryError("cannot create trace class object")
trace = bt2_trace._Trace._create_from_ptr(trace_ptr)
def _check_field_class_create_status(self, ptr, type_name):
if ptr is None:
- raise bt2._MemoryError("cannot create {} field class".format(type_name))
+ raise bt2_error._MemoryError(
+ "cannot create {} field class".format(type_name)
+ )
@staticmethod
def _set_field_class_user_attrs(fc, user_attributes):
from bt2 import native_bt
from bt2 import utils as bt2_utils
-import bt2
+from bt2 import logging as bt2_logging
import itertools
from bt2 import message_iterator as bt2_message_iterator
from bt2 import port as bt2_port
from bt2 import component as bt2_component
from bt2 import value as bt2_value
from bt2 import plugin as bt2_plugin
+from bt2 import error as bt2_error
+from bt2 import query_executor as bt2_query_executor
+from bt2 import component_descriptor as bt2_component_descriptor
+from bt2 import mip as bt2_mip
+from bt2 import graph as bt2_graph
import datetime
from collections import namedtuple
import numbers
if logging_level is not None:
bt2_utils._check_log_level(logging_level)
- self._params = bt2.create_value(params)
+ self._params = bt2_value.create_value(params)
self._obj = obj
self._logging_level = logging_level
component_class,
params=None,
obj=None,
- logging_level=bt2.LoggingLevel.NONE,
+ logging_level=bt2_logging.LoggingLevel.NONE,
):
if type(params) is str:
params = {"inputs": [params]}
is_cc_object = isinstance(
component_class,
- (bt2._SourceComponentClassConst, bt2._FilterComponentClassConst),
+ (
+ bt2_component._SourceComponentClassConst,
+ bt2_component._FilterComponentClassConst,
+ ),
)
is_user_cc_type = isinstance(
component_class, bt2_component._UserComponentType
) and issubclass(
- component_class, (bt2._UserSourceComponent, bt2._UserFilterComponent)
+ component_class,
+ (bt2_component._UserSourceComponent, bt2_component._UserFilterComponent),
)
if not is_cc_object and not is_user_cc_type:
component_class_name,
params=None,
obj=None,
- logging_level=bt2.LoggingLevel.NONE,
+ logging_level=bt2_logging.LoggingLevel.NONE,
):
- plugin = bt2.find_plugin(plugin_name)
+ plugin = bt2_plugin.find_plugin(plugin_name)
if plugin is None:
raise ValueError("no such plugin: {}".format(plugin_name))
def _auto_discover_source_component_specs(auto_source_comp_specs, plugin_set):
# Transform a list of `AutoSourceComponentSpec` in a list of `ComponentSpec`
# using the automatic source discovery mechanism.
- inputs = bt2.ArrayValue([spec.input for spec in auto_source_comp_specs])
+ inputs = bt2_value.ArrayValue([spec.input for spec in auto_source_comp_specs])
if plugin_set is None:
- plugin_set = bt2.find_plugins()
+ plugin_set = bt2_plugin.find_plugins()
else:
bt2_utils._check_type(plugin_set, bt2_plugin._PluginSet)
)
if res_ptr is None:
- raise bt2._MemoryError("cannot auto discover source components")
+ raise bt2_error._MemoryError("cannot auto discover source components")
res = bt2_value._create_from_ptr(res_ptr)
- assert type(res) is bt2.MapValue
+ assert type(res) is bt2_value.MapValue
assert "status" in res
status = res["status"]
comp_specs = []
comp_specs_raw = res["results"]
- assert type(comp_specs_raw) is bt2.ArrayValue
+ assert type(comp_specs_raw) is bt2_value.ArrayValue
used_input_indices = set()
for comp_spec_raw in comp_specs_raw:
- assert type(comp_spec_raw) is bt2.ArrayValue
+ assert type(comp_spec_raw) is bt2_value.ArrayValue
assert len(comp_spec_raw) == 4
plugin_name = comp_spec_raw[0]
- assert type(plugin_name) is bt2.StringValue
+ assert type(plugin_name) is bt2_value.StringValue
plugin_name = str(plugin_name)
class_name = comp_spec_raw[1]
- assert type(class_name) is bt2.StringValue
+ assert type(class_name) is bt2_value.StringValue
class_name = str(class_name)
comp_inputs = comp_spec_raw[2]
- assert type(comp_inputs) is bt2.ArrayValue
+ assert type(comp_inputs) is bt2_value.ArrayValue
comp_orig_indices = comp_spec_raw[3]
assert type(comp_orig_indices)
- params = bt2.MapValue()
- logging_level = bt2.LoggingLevel.NONE
+ params = bt2_value.MapValue()
+ logging_level = bt2_logging.LoggingLevel.NONE
obj = None
# Compute `params` for this component by piling up params given to all
# Query the port's component for the `babeltrace.trace-infos`
# object which contains the range for each stream, from which we can
# compute the intersection of the streams in each trace.
- query_exec = bt2.QueryExecutor(
+ query_exec = bt2_query_executor.QueryExecutor(
src_comp_and_spec.spec.component_class,
"babeltrace.trace-infos",
src_comp_and_spec.spec.params,
return self._create_trimmer(begin, end, name)
def _create_muxer(self):
- plugin = bt2.find_plugin("utils")
+ plugin = bt2_plugin.find_plugin("utils")
if plugin is None:
raise RuntimeError('cannot find "utils" plugin (needed for the muxer)')
return self._graph.add_component(comp_cls, "muxer")
def _create_trimmer(self, begin_ns, end_ns, name):
- plugin = bt2.find_plugin("utils")
+ plugin = bt2_plugin.find_plugin("utils")
if plugin is None:
raise RuntimeError('cannot find "utils" plugin (needed for the trimmer)')
def append_comp_specs_descriptors(descriptors, comp_specs):
for comp_spec in comp_specs:
descriptors.append(
- bt2.ComponentDescriptor(
+ bt2_component_descriptor.ComponentDescriptor(
comp_spec.component_class, comp_spec.params, comp_spec.obj
)
)
)
append_comp_specs_descriptors(descriptors, [comp_spec])
- mip_version = bt2.get_greatest_operative_mip_version(descriptors)
+ mip_version = bt2_mip.get_greatest_operative_mip_version(descriptors)
if mip_version is None:
msg = "failed to find an operative message interchange protocol version (components are not interoperable)"
return mip_version
def _build_graph(self):
- self._graph = bt2.Graph(self._get_greatest_operative_mip_version())
+ self._graph = bt2_graph.Graph(self._get_greatest_operative_mip_version())
self._graph.add_port_added_listener(self._graph_port_added)
self._muxer_comp = self._create_muxer()
#
# Copyright (c) 2017 Philippe Proulx <pproulx@efficios.com>
-import bt2
+
from bt2 import logging as bt2_logging
from bt2 import native_bt
from bt2 import error as bt2_error
if status == native_bt.__BT_FUNC_STATUS_ERROR:
assert msg is not None
- raise bt2._Error(msg)
+ raise bt2_error._Error(msg)
elif status == native_bt.__BT_FUNC_STATUS_MEMORY_ERROR:
assert msg is not None
- raise bt2._MemoryError(msg)
+ raise bt2_error._MemoryError(msg)
elif status == native_bt.__BT_FUNC_STATUS_END:
if msg is None:
- raise bt2.Stop
+ raise Stop
else:
- raise bt2.Stop(msg)
+ raise Stop(msg)
elif status == native_bt.__BT_FUNC_STATUS_AGAIN:
if msg is None:
- raise bt2.TryAgain
+ raise TryAgain
else:
- raise bt2.TryAgain(msg)
+ raise TryAgain(msg)
elif status == native_bt.__BT_FUNC_STATUS_OVERFLOW_ERROR:
if msg is None:
- raise bt2._OverflowError
+ raise _OverflowError
else:
- raise bt2._OverflowError(msg)
+ raise _OverflowError(msg)
elif status == native_bt.__BT_FUNC_STATUS_UNKNOWN_OBJECT:
if msg is None:
- raise bt2.UnknownObject
+ raise UnknownObject
else:
- raise bt2.UnknownObject(msg)
+ raise UnknownObject(msg)
else:
assert False
from bt2 import native_bt
from bt2 import object as bt2_object
from bt2 import utils as bt2_utils
+from bt2 import error as bt2_error
import collections.abc
import functools
import numbers
import math
import abc
-import bt2
def _create_from_ptr_template(ptr, object_map):
def _check_create_status(self, ptr):
if ptr is None:
- raise bt2._MemoryError(
+ raise bt2_error._MemoryError(
"cannot create {} value object".format(self._NAME.lower())
)
projects / babeltrace.git / commitdiff
