python: Add a ConfigKey class.

[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 89049cc4a15b94f993209fd6e196ff84260ad632..2998b4126b6bf2a26a3ba9306410e5e7b18f74e9 100644 (file)
--- a/bindings/python/sigrok/core/classes.py
+++ b/bindings/python/sigrok/core/classes.py
@@ -1,5 +1,5 @@
 ##
-## This file is part of the sigrok project.
+## This file is part of the libsigrok project.
 ##
 ## Copyright (C) 2013 Martin Ling <martin-sigrok@earth.li>
 ##
@@ -23,7 +23,8 @@ from .lowlevel import *
 from . import lowlevel
 import itertools
 
-__all__ = ['Error', 'Context', 'Driver', 'Device', 'Session', 'Packet', 'Log']
+__all__ = ['Error', 'Context', 'Driver', 'Device', 'Session', 'Packet', 'Log',
+    'LogLevel', 'PacketType', 'Quantity', 'Unit', 'QuantityFlag', 'ConfigKey']
 
 class Error(Exception):
 
@@ -34,12 +35,6 @@ def check(result):
     if result != SR_OK:
         raise Error(result)
 
-def config_key(name):
-    if not name.lower() == name:
-        raise AttributeError
-    key_name = "SR_CONF_" + name.upper()
-    return getattr(lowlevel, key_name)
-
 def gvariant_to_python(value):
     type_string = g_variant_get_type_string(value)
     if type_string == 't':
@@ -68,8 +63,10 @@ def python_to_gvariant(value):
         return g_variant_new_string(value)
     if isinstance(value, Fraction):
         array = new_gvariant_ptr_array(2)
-        gvariant_ptr_array_setitem(array, 0, value.numerator)
-        gvariant_ptr_array_setitem(array, 1, value.denominator)
+        gvariant_ptr_array_setitem(array, 0,
+            g_variant_new_uint64(value.numerator))
+        gvariant_ptr_array_setitem(array, 1,
+            g_variant_new_uint64(value.denominator))
         result = g_variant_new_tuple(array, 2)
         delete_gvariant_ptr_array(array)
         return result
@@ -122,14 +119,9 @@ class Driver(object):
         if not self._initialized:
             check(sr_driver_init(self.context.struct, self.struct))
             self._initialized = True
-        devices = []
         device_list = sr_driver_scan(self.struct, None)
-        device_list_item = device_list
-        while device_list_item:
-            ptr = device_list_item.data
-            device_ptr = gpointer_to_sr_dev_inst_ptr(ptr)
-            devices.append(Device(self, device_ptr))
-            device_list_item = device_list_item.next
+        devices = [Device(self, gpointer_to_sr_dev_inst_ptr(ptr))
+            for ptr in gslist_to_python(device_list)]
         g_slist_free(device_list)
         return devices
 
@@ -147,10 +139,11 @@ class Device(object):
         self.struct = struct
 
     def __getattr__(self, name):
-        key = config_key(name)
+        key = getattr(ConfigKey, name.upper())
         data = new_gvariant_ptr_ptr()
         try:
-            check(sr_config_get(self.driver.struct, key, data, self.struct))
+            check(sr_config_get(self.driver.struct,
+                key.id, data, self.struct))
         except Error as error:
             if error.errno == SR_ERR_NA:
                 raise NotImplementedError(
@@ -162,11 +155,12 @@ class Device(object):
 
     def __setattr__(self, name, value):
         try:
-            key = config_key(name)
+            key = getattr(ConfigKey, name.upper())
         except AttributeError:
             super(Device, self).__setattr__(name, value)
             return
-        check(sr_config_set(self.struct, key, python_to_gvariant(value)))
+        check(sr_config_set(self.struct,
+            key.id, python_to_gvariant(value)))
 
     @property
     def vendor(self):
@@ -216,16 +210,16 @@ class Packet(object):
 
     @property
     def type(self):
-        return self.struct.type
+        return PacketType(self.struct.type)
 
     @property
     def payload(self):
         if self._payload is None:
             pointer = self.struct.payload
-            if self.struct.type == SR_DF_LOGIC:
+            if self.type == PacketType.LOGIC:
                 self._payload = Logic(self,
                     void_ptr_to_sr_datafeed_logic_ptr(pointer))
-            elif self.struct.type == SR_DF_ANALOG:
+            elif self.type == PacketType.ANALOG:
                 self._payload = Analog(self,
                     void_ptr_to_sr_datafeed_analog_ptr(pointer))
             else:
@@ -259,15 +253,15 @@ class Analog(object):
 
     @property
     def mq(self):
-        return self.struct.mq
+        return Quantity(self.struct.mq)
 
     @property
     def unit(self):
-        return self.struct.unit
+        return Unit(self.struct.unit)
 
     @property
     def mqflags(self):
-        return self.struct.mqflags
+        return QuantityFlag.set_from_mask(self.struct.mqflags)
 
     @property
     def data(self):
@@ -277,20 +271,13 @@ class Analog(object):
 
 class Log(object):
 
-    NONE = SR_LOG_NONE
-    ERR = SR_LOG_ERR
-    WARN = SR_LOG_WARN
-    INFO = SR_LOG_INFO
-    DBG = SR_LOG_DBG
-    SPEW = SR_LOG_SPEW
-
     @property
     def level(self):
-        return sr_log_loglevel_get()
+        return LogLevel(sr_log_loglevel_get())
 
     @level.setter
     def level(self, l):
-        check(sr_log_loglevel_set(l))
+        check(sr_log_loglevel_set(l.id))
 
     @property
     def domain(self):
@@ -300,8 +287,54 @@ class Log(object):
     def domain(self, d):
         check(sr_log_logdomain_set(d))
 
+class EnumValue(object):
+
+    _enum_values = {}
+
+    def __new__(cls, id):
+        if cls not in cls._enum_values:
+            cls._enum_values[cls] = {}
+        if id not in cls._enum_values[cls]:
+            value = super(EnumValue, cls).__new__(cls)
+            value.id = id
+            cls._enum_values[cls][id] = value
+        return cls._enum_values[cls][id]
+
+class LogLevel(EnumValue):
+    pass
+
+class PacketType(EnumValue):
+    pass
+
+class Quantity(EnumValue):
+    pass
+
+class Unit(EnumValue):
+    pass
+
+class QuantityFlag(EnumValue):
+
+    @classmethod
+    def set_from_mask(cls, mask):
+        result = set()
+        while mask:
+            new_mask = mask & (mask - 1)
+            result.add(cls(mask ^ new_mask))
+            mask = new_mask
+        return result
+
+class ConfigKey(EnumValue):
+    pass
+
 for symbol_name in dir(lowlevel):
-    prefix = 'SR_DF_'
-    if symbol_name.startswith(prefix):
-        name = symbol_name[len(prefix):]
-        setattr(Packet, name, getattr(lowlevel, symbol_name))
+    for prefix, cls in [
+        ('SR_LOG_', LogLevel),
+        ('SR_DF_', PacketType),
+        ('SR_MQ_', Quantity),
+        ('SR_UNIT_', Unit),
+        ('SR_MQFLAG_', QuantityFlag),
+        ('SR_CONF_', ConfigKey)]:
+        if symbol_name.startswith(prefix):
+            name = symbol_name[len(prefix):]
+            value = getattr(lowlevel, symbol_name)
+            setattr(cls, name, cls(value))