schema: get more info from enums/bits

Return python objects instead of tuples of (name, description).

This is an API breakage (although, minor).

Signed-off-by: Robin Jarry <robin@jarry.cc>

Author: rjarry

cffi/cdefs.h

@@ -151,6 +151,7 @@ struct lys_type_info_binary {
 struct lys_type_bit {
 	const char *name;
 	const char *dsc;
+	uint16_t flags;
 	uint32_t pos;
 	...;
 };
@@ -168,6 +169,7 @@ struct lys_type_info_dec64 {
 struct lys_type_enum {
 	const char *name;
 	const char *dsc;
+	uint16_t flags;
 	...;
 };
 

libyang/__init__.py

@@ -10,6 +10,8 @@
     BaseTypeRemoved,
     BitAdded,
     BitRemoved,
+    BitStatusAdded,
+    BitStatusRemoved,
     ConfigFalseAdded,
     ConfigFalseRemoved,
     DefaultAdded,
@@ -18,6 +20,8 @@
     DescriptionRemoved,
     EnumAdded,
     EnumRemoved,
+    EnumStatusAdded,
+    EnumStatusRemoved,
     ExtensionAdded,
     ExtensionRemoved,
     KeyAdded,

libyang/diff.py

@@ -142,6 +142,14 @@ class BitAdded(SNodeAttributeChanged):
     pass
 
 
+class BitStatusRemoved(SNodeAttributeChanged):
+    pass
+
+
+class BitStatusAdded(SNodeAttributeChanged):
+    pass
+
+
 class ConfigFalseRemoved(SNodeAttributeChanged):
     pass
 
@@ -174,6 +182,14 @@ class EnumAdded(SNodeAttributeChanged):
     pass
 
 
+class EnumStatusRemoved(SNodeAttributeChanged):
+    pass
+
+
+class EnumStatusAdded(SNodeAttributeChanged):
+    pass
+
+
 class ExtensionRemoved(SNodeAttributeChanged):
     pass
 
@@ -365,19 +381,31 @@ def snode_changes(old: SNode, new: SNode) -> Iterator[SNodeDiff]:
         for r in new_ranges - old_ranges:
             yield RangeAdded(old, new, r)
 
-        old_enums = set(e for e, _ in old.type().all_enums())
-        new_enums = set(e for e, _ in new.type().all_enums())
-        for e in old_enums - new_enums:
-            yield EnumRemoved(old, new, e)
-        for e in new_enums - old_enums:
-            yield EnumAdded(old, new, e)
-
-        old_bits = set(b for b, _ in old.type().all_bits())
-        new_bits = set(b for b, _ in new.type().all_bits())
-        for b in old_bits - new_bits:
-            yield BitRemoved(old, new, b)
-        for b in new_bits - old_bits:
-            yield BitAdded(old, new, b)
+        old_enums = {e.name(): e for e in old.type().all_enums()}
+        new_enums = {e.name(): e for e in new.type().all_enums()}
+        for e in old_enums.keys() - new_enums.keys():
+            yield EnumRemoved(old, new, old_enums[e])
+        for e in new_enums.keys() - old_enums.keys():
+            yield EnumAdded(old, new, new_enums[e])
+        for e in new_enums.keys() & old_enums.keys():
+            o = old_enums[e]
+            n = new_enums[e]
+            if o.status() != n.status():
+                yield EnumStatusRemoved(old, new, (o.name(), o.status()))
+                yield EnumStatusAdded(old, new, (n.name(), n.status()))
+
+        old_bits = {b.name(): b for b in old.type().all_bits()}
+        new_bits = {b.name(): b for b in new.type().all_bits()}
+        for b in old_bits.keys() - new_bits.keys():
+            yield BitRemoved(old, new, old_bits[b])
+        for b in new_bits.keys() - old_bits.keys():
+            yield BitAdded(old, new, new_bits[b])
+        for b in new_bits.keys() & old_bits.keys():
+            o = old_bits[b]
+            n = new_bits[b]
+            if o.status() != n.status():
+                yield BitStatusRemoved(old, new, (o.name(), o.status()))
+                yield BitStatusAdded(old, new, (n.name(), n.status()))
 
     if isinstance(old, SLeaf) and isinstance(new, SLeaf):
         if old.default() != new.default():

libyang/schema.py

@@ -281,6 +281,52 @@ def __str__(self):
         return self.name()
 
 
+# -------------------------------------------------------------------------------------
+class _EnumBit:
+
+    __slots__ = ("context", "cdata")
+
+    def __init__(self, context: "libyang.Context", cdata):
+        self.context = context
+        self.cdata = cdata  # C type "struct lys_type_bit" or "struct lys_type_enum"
+
+    def name(self) -> str:
+        return c2str(self.cdata.name)
+
+    def description(self) -> str:
+        return c2str(self.cdata.dsc)
+
+    def deprecated(self) -> bool:
+        return bool(self.cdata.flags & lib.LYS_STATUS_DEPRC)
+
+    def obsolete(self) -> bool:
+        return bool(self.cdata.flags & lib.LYS_STATUS_OBSLT)
+
+    def status(self) -> str:
+        if self.cdata.flags & lib.LYS_STATUS_OBSLT:
+            return "obsolete"
+        if self.cdata.flags & lib.LYS_STATUS_DEPRC:
+            return "deprecated"
+        return "current"
+
+    def __repr__(self):
+        cls = self.__class__
+        return "<%s.%s: %s>" % (cls.__module__, cls.__name__, self)
+
+    def __str__(self):
+        return self.name()
+
+
+# -------------------------------------------------------------------------------------
+class Enum(_EnumBit):
+    pass
+
+
+# -------------------------------------------------------------------------------------
+class Bit(_EnumBit):
+    pass
+
+
 # -------------------------------------------------------------------------------------
 class Type:
 
@@ -393,31 +439,29 @@ def union_types(self) -> Iterator["Type"]:
         for i in range(t.info.uni.count):
             yield Type(self.context, t.info.uni.types[i])
 
-    def enums(self) -> Iterator[Tuple[str, Optional[str]]]:
+    def enums(self) -> Iterator[Enum]:
         if self.cdata.base != self.ENUM:
             return
         t = self.cdata
         while t.info.enums.count == 0:
             t = ffi.addressof(t.der.type)
         for i in range(t.info.enums.count):
-            e = t.info.enums.enm[i]
-            yield c2str(e.name), c2str(e.dsc)
+            yield Enum(self.context, t.info.enums.enm[i])
 
-    def all_enums(self) -> Iterator[Tuple[str, Optional[str]]]:
+    def all_enums(self) -> Iterator[Enum]:
         for b in self.get_bases():
             yield from b.enums()
 
-    def bits(self) -> Iterator[Tuple[str, Optional[str]]]:
+    def bits(self) -> Iterator[Bit]:
         if self.cdata.base != self.BITS:
             return
         t = self.cdata
         while t.info.bits.count == 0:
             t = ffi.addressof(t.der.type)
         for i in range(t.info.bits.count):
-            b = t.info.bits.bit[i]
-            yield c2str(b.name), c2str(b.dsc)
+            yield Bit(self.context, t.info.bits.bit[i])
 
-    def all_bits(self) -> Iterator[Tuple[str, Optional[str]]]:
+    def all_bits(self) -> Iterator[Bit]:
         for b in self.get_bases():
             yield from b.bits()
 

tests/test_diff.py

@@ -8,6 +8,9 @@
     BaseTypeAdded,
     BaseTypeRemoved,
     Context,
+    EnumRemoved,
+    EnumStatusAdded,
+    EnumStatusRemoved,
     NodeTypeAdded,
     NodeTypeRemoved,
     SNodeAdded,
@@ -68,6 +71,12 @@ class DiffTest(unittest.TestCase):
             (SNodeAdded, "/yolo-system:alarm-triggered"),
             (SNodeAdded, "/yolo-system:alarm-triggered/yolo-system:severity"),
             (SNodeAdded, "/yolo-system:alarm-triggered/yolo-system:description"),
+            (EnumRemoved, "/yolo-system:conf/yolo-system:url/yolo-system:proto"),
+            (EnumRemoved, "/yolo-system:state/yolo-system:url/yolo-system:proto"),
+            (EnumStatusAdded, "/yolo-system:conf/yolo-system:url/yolo-system:proto"),
+            (EnumStatusAdded, "/yolo-system:state/yolo-system:url/yolo-system:proto"),
+            (EnumStatusRemoved, "/yolo-system:conf/yolo-system:url/yolo-system:proto"),
+            (EnumStatusRemoved, "/yolo-system:state/yolo-system:url/yolo-system:proto"),
         )
     )
 

tests/test_schema.py

@@ -346,8 +346,8 @@ def test_leaf_type_enum(self):
         self.assertIsInstance(t, Type)
         self.assertEqual(t.name(), "protocol")
         self.assertEqual(t.base(), Type.ENUM)
-        enums = [e for e, _ in t.enums()]
-        self.assertEqual(enums, ["http", "https", "ftp", "sftp", "tftp"])
+        enums = [e.name() for e in t.enums()]
+        self.assertEqual(enums, ["http", "https", "ftp", "sftp"])
 
     def test_leaf_type_bits(self):
         leaf = next(
@@ -358,7 +358,7 @@ def test_leaf_type_bits(self):
         self.assertIsInstance(t, Type)
         self.assertEqual(t.name(), "permissions")
         self.assertEqual(t.base(), Type.BITS)
-        bits = [b for b, _ in t.bits()]
+        bits = [b.name() for b in t.bits()]
         self.assertEqual(bits, ["read", "write", "execute"])
         self.assertIs(t.derived_type().module(), None)
 

tests/yang/wtf/wtf-types.yang

@@ -37,9 +37,10 @@ module wtf-types {
     type enumeration {
       enum http;
       enum https;
-      enum ftp;
+      enum ftp {
+        status deprecated;
+      }
       enum sftp;
-      enum tftp;
     }
   }