python: Add initial support for input and output formats.

[libsigrok.git] / bindings / python / sigrok / core / classes.py

diff --git a/bindings/python/sigrok/core/classes.py b/bindings/python/sigrok/core/classes.py
index f4d2e60e9f40fe2a8e8b7dd4515830e50d33b31b..6b55eb3f99754c7c431290898961874776097e59 100644 (file)
--- a/bindings/python/sigrok/core/classes.py
+++ b/bindings/python/sigrok/core/classes.py
@@ -24,7 +24,8 @@ from . import lowlevel
 import itertools
 
 __all__ = ['Error', 'Context', 'Driver', 'Device', 'Session', 'Packet', 'Log',
-    'LogLevel', 'PacketType', 'Quantity', 'Unit', 'QuantityFlag', 'ConfigKey']
+    'LogLevel', 'PacketType', 'Quantity', 'Unit', 'QuantityFlag', 'ConfigKey',
+    'ProbeType', 'Probe', 'ProbeGroup']
 
 class Error(Exception):
 
@@ -86,6 +87,8 @@ class Context(object):
         self.struct = sr_context_ptr_ptr_value(context_ptr_ptr)
         self._drivers = None
         self._devices = {}
+        self._input_formats = None
+        self._output_formats = None
         self.session = None
 
     def __del__(self):
@@ -104,6 +107,32 @@ class Context(object):
                     break
         return self._drivers
 
+    @property
+    def input_formats(self):
+        if not self._input_formats:
+            self._input_formats = {}
+            input_list = sr_input_list()
+            for i in itertools.count():
+                input_ptr = sr_input_format_ptr_array_getitem(input_list, i)
+                if input_ptr:
+                    self._input_formats[input_ptr.id] = InputFormat(self, input_ptr)
+                else:
+                    break
+        return self._input_formats
+
+    @property
+    def output_formats(self):
+        if not self._output_formats:
+            self._output_formats = {}
+            output_list = sr_output_list()
+            for i in itertools.count():
+                output_ptr = sr_output_format_ptr_array_getitem(output_list, i)
+                if output_ptr:
+                    self._output_formats[output_ptr.id] = OutputFormat(self, output_ptr)
+                else:
+                    break
+        return self._output_formats
+
 class Driver(object):
 
     def __init__(self, context, struct):
@@ -146,13 +175,15 @@ class Device(object):
     def __init__(self, driver, struct):
         self.driver = driver
         self.struct = struct
+        self._probes = None
+        self._probe_groups = None
 
     def __getattr__(self, name):
         key = getattr(ConfigKey, name.upper())
         data = new_gvariant_ptr_ptr()
         try:
-            check(sr_config_get(self.driver.struct,
-                key.id, data, self.struct))
+            check(sr_config_get(self.driver.struct, self.struct, None,
+                key.id, data))
         except Error as error:
             if error.errno == SR_ERR_NA:
                 raise NotImplementedError(
@@ -168,8 +199,7 @@ class Device(object):
         except AttributeError:
             super(Device, self).__setattr__(name, value)
             return
-        check(sr_config_set(self.struct,
-            key.id, python_to_gvariant(value)))
+        check(sr_config_set(self.struct, None, key.id, python_to_gvariant(value)))
 
     @property
     def vendor(self):
@@ -183,6 +213,97 @@ class Device(object):
     def version(self):
         return self.struct.version
 
+    @property
+    def probes(self):
+        if self._probes is None:
+            self._probes = {}
+            probe_list = self.struct.probes
+            while (probe_list):
+                probe_ptr = void_ptr_to_sr_probe_ptr(probe_list.data)
+                self._probes[probe_ptr.name] = Probe(self, probe_ptr)
+                probe_list = probe_list.next
+        return self._probes
+
+    @property
+    def probe_groups(self):
+        if self._probe_groups is None:
+            self._probe_groups = {}
+            probe_group_list = self.struct.probe_groups
+            while (probe_group_list):
+                probe_group_ptr = void_ptr_to_sr_probe_group_ptr(
+                    probe_group_list.data)
+                self._probe_groups[probe_group_ptr.name] = ProbeGroup(self,
+                    probe_group_ptr)
+                probe_group_list = probe_group_list.next
+        return self._probe_groups
+
+class Probe(object):
+
+    def __init__(self, device, struct):
+        self.device = device
+        self.struct = struct
+
+    @property
+    def type(self):
+        return ProbeType(self.struct.type)
+
+    @property
+    def enabled(self):
+        return self.struct.enabled
+
+    @property
+    def name(self):
+        return self.struct.name
+
+class ProbeGroup(object):
+
+    def __init__(self, device, struct):
+        self.device = device
+        self.struct = struct
+        self._probes = None
+
+    def __iter__(self):
+        return iter(self.probes)
+
+    def __getattr__(self, name):
+        key = config_key(name)
+        data = new_gvariant_ptr_ptr()
+        try:
+            check(sr_config_get(self.device.driver.struct, self.device.struct,
+                self.struct, key.id, data))
+        except Error as error:
+            if error.errno == SR_ERR_NA:
+                raise NotImplementedError(
+                    "Probe group does not implement %s" % name)
+            else:
+                raise AttributeError
+        value = gvariant_ptr_ptr_value(data)
+        return gvariant_to_python(value)
+
+    def __setattr__(self, name, value):
+        try:
+            key = config_key(name)
+        except AttributeError:
+            super(ProbeGroup, self).__setattr__(name, value)
+            return
+        check(sr_config_set(self.device.struct, self.struct,
+            key.id, python_to_gvariant(value)))
+
+    @property
+    def name(self):
+        return self.struct.name
+
+    @property
+    def probes(self):
+        if self._probes is None:
+            self._probes = []
+            probe_list = self.struct.probes
+            while (probe_list):
+                probe_ptr = void_ptr_to_sr_probe_ptr(probe_list.data)
+                self._probes.append(Probe(self, probe_ptr))
+                probe_list = probe_list.next
+        return self._probes
+
 class Session(object):
 
     def __init__(self, context):
@@ -236,7 +357,7 @@ class Packet(object):
                     void_ptr_to_sr_datafeed_analog_ptr(pointer))
             else:
                 raise NotImplementedError(
-                    "No Python mapping for packet type %ѕ" % self.struct.type)
+                    "No Python mapping for packet type %s" % self.struct.type)
         return self._payload
 
 class Logic(object):
@@ -299,6 +420,34 @@ class Log(object):
     def domain(self, d):
         check(sr_log_logdomain_set(d))
 
+class InputFormat(object):
+
+    def __init__(self, context, struct):
+        self.context = context
+        self.struct = struct
+
+    @property
+    def id(self):
+        return self.struct.id
+
+    @property
+    def description(self):
+        return self.struct.description
+
+class OutputFormat(object):
+
+    def __init__(self, context, struct):
+        self.context = context
+        self.struct = struct
+
+    @property
+    def id(self):
+        return self.struct.id
+
+    @property
+    def description(self):
+        return self.struct.description
+
 class EnumValue(object):
 
     _enum_values = {}
@@ -338,6 +487,9 @@ class QuantityFlag(EnumValue):
 class ConfigKey(EnumValue):
     pass
 
+class ProbeType(EnumValue):
+    pass
+
 for symbol_name in dir(lowlevel):
     for prefix, cls in [
         ('SR_LOG_', LogLevel),
@@ -345,7 +497,8 @@ for symbol_name in dir(lowlevel):
         ('SR_MQ_', Quantity),
         ('SR_UNIT_', Unit),
         ('SR_MQFLAG_', QuantityFlag),
-        ('SR_CONF_', ConfigKey)]:
+        ('SR_CONF_', ConfigKey),
+        ('SR_PROBE_', ProbeType)]:
         if symbol_name.startswith(prefix):
             name = symbol_name[len(prefix):]
             value = getattr(lowlevel, symbol_name)