schema: add typedef support

Parse the typedef section in a Typedef class, add typedefs / get_typedef
methods to the Module class, and add a method to get the Typedef object
associated to a Type.

Signed-off-by: Samuel Gauthier <samuel.gauthier@6wind.com>
Acked-by: Robin Jarry <robin@jarry.cc>

Author: samuel-gauthier

cffi/cdefs.h

@@ -978,6 +978,17 @@ LY_ERR lyd_dup_siblings(const struct lyd_node *, struct lyd_node_inner *, uint32
 LY_ERR lyd_dup_single(const struct lyd_node *, struct lyd_node_inner *, uint32_t, struct lyd_node **);
 void lyd_free_meta_single(struct lyd_meta *);
 
+struct lysp_tpdf {
+    const char *name;
+    const char *units;
+    struct lysp_qname dflt;
+    const char *dsc;
+    const char *ref;
+    struct lysp_ext_instance *exts;
+    struct lysp_type type;
+    uint16_t flags;
+};
+
 struct lysc_when {
     struct lyxp_expr *cond;
     struct lysc_node *context;

libyang/__init__.py

@@ -83,6 +83,7 @@
     SRpc,
     SRpcInOut,
     Type,
+    Typedef,
 )
 from .util import DataType, IOType, LibyangError
 from .xpath import (

libyang/schema.py

@@ -112,6 +112,17 @@ def revisions(self) -> Iterator["Revision"]:
         for revision in ly_array_iter(self.cdata.parsed.revs):
             yield Revision(self.context, revision, self)
 
+    def typedefs(self) -> Iterator["Typedef"]:
+        for typedef in ly_array_iter(self.cdata.parsed.typedefs):
+            yield Typedef(self.context, typedef)
+
+    def get_typedef(self, name: str) -> Optional["Typedef"]:
+        for typedef in self.typedefs():
+            if typedef.name() != name:
+                continue
+            return typedef
+        return None
+
     def imports(self) -> Iterator["Import"]:
         for i in ly_array_iter(self.cdata.parsed.imports):
             yield Import(self.context, i, self)
@@ -533,6 +544,14 @@ def leafref_path(self) -> Optional["str"]:
         lr = ffi.cast("struct lysc_type_leafref *", self.cdata)
         return c2str(lib.lyxp_get_expr(lr.path))
 
+    def typedef(self) -> "Typedef":
+        if ":" in self.name():
+            module_prefix, type_name = self.name().split(":")
+            import_module = self.module().get_module_from_prefix(module_prefix)
+            if import_module:
+                return import_module.get_typedef(type_name)
+        return None
+
     def union_types(self) -> Iterator["Type"]:
         if self.cdata.basetype != self.UNION:
             return
@@ -662,6 +681,59 @@ def __str__(self):
         return self.name()
 
 
+# -------------------------------------------------------------------------------------
+class Typedef:
+    __slots__ = ("context", "cdata", "__dict__")
+
+    def __init__(self, context: "libyang.Context", cdata):
+        self.context = context
+        self.cdata = cdata  # C type: "struct lysp_tpdf *"
+
+    def name(self) -> str:
+        return c2str(self.cdata.name)
+
+    def description(self) -> Optional[str]:
+        return c2str(self.cdata.dsc)
+
+    def units(self) -> Optional[str]:
+        return c2str(self.cdata.units)
+
+    def reference(self) -> Optional[str]:
+        return c2str(self.cdata.ref)
+
+    def extensions(self) -> Iterator[ExtensionCompiled]:
+        ext = ffi.cast("struct lysc_ext_instance *", self.cdata.exts)
+        if ext == ffi.NULL:
+            return
+        for extension in ly_array_iter(ext):
+            yield ExtensionCompiled(self.context, extension)
+
+    def get_extension(
+        self, name: str, prefix: Optional[str] = None, arg_value: Optional[str] = None
+    ) -> Optional[ExtensionCompiled]:
+        for ext in self.extensions():
+            if ext.name() != name:
+                continue
+            if prefix is not None and ext.module().name() != prefix:
+                continue
+            if arg_value is not None and ext.argument() != arg_value:
+                continue
+            return ext
+        return None
+
+    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 module(self) -> Module:
+        return Module(self.context, self.cdata.module)
+
+    def __str__(self):
+        return self.name()
+
+
 # -------------------------------------------------------------------------------------
 class Feature:
     __slots__ = ("context", "cdata", "__dict__")

tests/test_schema.py

@@ -380,6 +380,8 @@ def test_leaf_type_derived(self):
         self.assertIsNot(mod, None)
         self.assertEqual(mod.name(), "yolo-system")
         self.assertEqual(mod.get_module_from_prefix("types").name(), "wtf-types")
+        self.assertEqual(t.typedef().name(), "host")
+        self.assertEqual(t.typedef().description(), "my host type.")
 
     def test_leaf_type_status(self):
         leaf = next(self.ctx.find_path("/yolo-system:conf/yolo-system:hostname"))

tests/yang/wtf/wtf-types.yang

@@ -12,6 +12,8 @@ module wtf-types {
     type str {
       pattern "[a-z]+";
     }
+    description
+      "my host type.";
   }
 
   extension signed;