~lttng/babeltrace/trunk

« back to all changes in this revision

Viewing changes to src/bindings/python/bt2/bt2/trace_collection_message_iterator.py

  • Committer: Philippe Proulx
  • Author(s): Simon Marchi
  • Date: 2023-09-21 17:29:44 UTC
  • Revision ID: git-v1:c345b07873b0cb0ed344bde32a322a1b1edf60ae
python: remove internal `import bt2` imports

Standardize the internal imports to import specific modules like this:

    from bt2 import foo as bt2_foo

... instead of importing the complete bt2 package.

Change-Id: I32eb223a8bcfe841020a2aafb976f121dadd8680
Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/10388
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
4
4
 
5
5
from bt2 import native_bt
6
6
from bt2 import utils as bt2_utils
7
 
import bt2
 
7
from bt2 import logging as bt2_logging
8
8
import itertools
9
9
from bt2 import message_iterator as bt2_message_iterator
10
10
from bt2 import port as bt2_port
11
11
from bt2 import component as bt2_component
12
12
from bt2 import value as bt2_value
13
13
from bt2 import plugin as bt2_plugin
 
14
from bt2 import error as bt2_error
 
15
from bt2 import query_executor as bt2_query_executor
 
16
from bt2 import component_descriptor as bt2_component_descriptor
 
17
from bt2 import mip as bt2_mip
 
18
from bt2 import graph as bt2_graph
14
19
import datetime
15
20
from collections import namedtuple
16
21
import numbers
27
32
        if logging_level is not None:
28
33
            bt2_utils._check_log_level(logging_level)
29
34
 
30
 
        self._params = bt2.create_value(params)
 
35
        self._params = bt2_value.create_value(params)
31
36
        self._obj = obj
32
37
        self._logging_level = logging_level
33
38
 
51
56
        component_class,
52
57
        params=None,
53
58
        obj=None,
54
 
        logging_level=bt2.LoggingLevel.NONE,
 
59
        logging_level=bt2_logging.LoggingLevel.NONE,
55
60
    ):
56
61
        if type(params) is str:
57
62
            params = {"inputs": [params]}
60
65
 
61
66
        is_cc_object = isinstance(
62
67
            component_class,
63
 
            (bt2._SourceComponentClassConst, bt2._FilterComponentClassConst),
 
68
            (
 
69
                bt2_component._SourceComponentClassConst,
 
70
                bt2_component._FilterComponentClassConst,
 
71
            ),
64
72
        )
65
73
        is_user_cc_type = isinstance(
66
74
            component_class, bt2_component._UserComponentType
67
75
        ) and issubclass(
68
 
            component_class, (bt2._UserSourceComponent, bt2._UserFilterComponent)
 
76
            component_class,
 
77
            (bt2_component._UserSourceComponent, bt2_component._UserFilterComponent),
69
78
        )
70
79
 
71
80
        if not is_cc_object and not is_user_cc_type:
88
97
        component_class_name,
89
98
        params=None,
90
99
        obj=None,
91
 
        logging_level=bt2.LoggingLevel.NONE,
 
100
        logging_level=bt2_logging.LoggingLevel.NONE,
92
101
    ):
93
 
        plugin = bt2.find_plugin(plugin_name)
 
102
        plugin = bt2_plugin.find_plugin(plugin_name)
94
103
 
95
104
        if plugin is None:
96
105
            raise ValueError("no such plugin: {}".format(plugin_name))
125
134
def _auto_discover_source_component_specs(auto_source_comp_specs, plugin_set):
126
135
    # Transform a list of `AutoSourceComponentSpec` in a list of `ComponentSpec`
127
136
    # using the automatic source discovery mechanism.
128
 
    inputs = bt2.ArrayValue([spec.input for spec in auto_source_comp_specs])
 
137
    inputs = bt2_value.ArrayValue([spec.input for spec in auto_source_comp_specs])
129
138
 
130
139
    if plugin_set is None:
131
 
        plugin_set = bt2.find_plugins()
 
140
        plugin_set = bt2_plugin.find_plugins()
132
141
    else:
133
142
        bt2_utils._check_type(plugin_set, bt2_plugin._PluginSet)
134
143
 
137
146
    )
138
147
 
139
148
    if res_ptr is None:
140
 
        raise bt2._MemoryError("cannot auto discover source components")
 
149
        raise bt2_error._MemoryError("cannot auto discover source components")
141
150
 
142
151
    res = bt2_value._create_from_ptr(res_ptr)
143
152
 
144
 
    assert type(res) is bt2.MapValue
 
153
    assert type(res) is bt2_value.MapValue
145
154
    assert "status" in res
146
155
 
147
156
    status = res["status"]
149
158
 
150
159
    comp_specs = []
151
160
    comp_specs_raw = res["results"]
152
 
    assert type(comp_specs_raw) is bt2.ArrayValue
 
161
    assert type(comp_specs_raw) is bt2_value.ArrayValue
153
162
 
154
163
    used_input_indices = set()
155
164
 
156
165
    for comp_spec_raw in comp_specs_raw:
157
 
        assert type(comp_spec_raw) is bt2.ArrayValue
 
166
        assert type(comp_spec_raw) is bt2_value.ArrayValue
158
167
        assert len(comp_spec_raw) == 4
159
168
 
160
169
        plugin_name = comp_spec_raw[0]
161
 
        assert type(plugin_name) is bt2.StringValue
 
170
        assert type(plugin_name) is bt2_value.StringValue
162
171
        plugin_name = str(plugin_name)
163
172
 
164
173
        class_name = comp_spec_raw[1]
165
 
        assert type(class_name) is bt2.StringValue
 
174
        assert type(class_name) is bt2_value.StringValue
166
175
        class_name = str(class_name)
167
176
 
168
177
        comp_inputs = comp_spec_raw[2]
169
 
        assert type(comp_inputs) is bt2.ArrayValue
 
178
        assert type(comp_inputs) is bt2_value.ArrayValue
170
179
 
171
180
        comp_orig_indices = comp_spec_raw[3]
172
181
        assert type(comp_orig_indices)
173
182
 
174
 
        params = bt2.MapValue()
175
 
        logging_level = bt2.LoggingLevel.NONE
 
183
        params = bt2_value.MapValue()
 
184
        logging_level = bt2_logging.LoggingLevel.NONE
176
185
        obj = None
177
186
 
178
187
        # Compute `params` for this component by piling up params given to all
330
339
            # Query the port's component for the `babeltrace.trace-infos`
331
340
            # object which contains the range for each stream, from which we can
332
341
            # compute the intersection of the streams in each trace.
333
 
            query_exec = bt2.QueryExecutor(
 
342
            query_exec = bt2_query_executor.QueryExecutor(
334
343
                src_comp_and_spec.spec.component_class,
335
344
                "babeltrace.trace-infos",
336
345
                src_comp_and_spec.spec.params,
392
401
        return self._create_trimmer(begin, end, name)
393
402
 
394
403
    def _create_muxer(self):
395
 
        plugin = bt2.find_plugin("utils")
 
404
        plugin = bt2_plugin.find_plugin("utils")
396
405
 
397
406
        if plugin is None:
398
407
            raise RuntimeError('cannot find "utils" plugin (needed for the muxer)')
406
415
        return self._graph.add_component(comp_cls, "muxer")
407
416
 
408
417
    def _create_trimmer(self, begin_ns, end_ns, name):
409
 
        plugin = bt2.find_plugin("utils")
 
418
        plugin = bt2_plugin.find_plugin("utils")
410
419
 
411
420
        if plugin is None:
412
421
            raise RuntimeError('cannot find "utils" plugin (needed for the trimmer)')
492
501
        def append_comp_specs_descriptors(descriptors, comp_specs):
493
502
            for comp_spec in comp_specs:
494
503
                descriptors.append(
495
 
                    bt2.ComponentDescriptor(
 
504
                    bt2_component_descriptor.ComponentDescriptor(
496
505
                        comp_spec.component_class, comp_spec.params, comp_spec.obj
497
506
                    )
498
507
                )
508
517
            )
509
518
            append_comp_specs_descriptors(descriptors, [comp_spec])
510
519
 
511
 
        mip_version = bt2.get_greatest_operative_mip_version(descriptors)
 
520
        mip_version = bt2_mip.get_greatest_operative_mip_version(descriptors)
512
521
 
513
522
        if mip_version is None:
514
523
            msg = "failed to find an operative message interchange protocol version (components are not interoperable)"
517
526
        return mip_version
518
527
 
519
528
    def _build_graph(self):
520
 
        self._graph = bt2.Graph(self._get_greatest_operative_mip_version())
 
529
        self._graph = bt2_graph.Graph(self._get_greatest_operative_mip_version())
521
530
        self._graph.add_port_added_listener(self._graph_port_added)
522
531
        self._muxer_comp = self._create_muxer()
523
532