data: add anydata and anyxml support to dict_to_dnode

dict_to_dnode() skips anydata and anyxml nodes. The schema lookup uses
the default iter_children() types, which do not include them, so these
keys are dropped as unknown elements.

Look them up as well, and create them with lyd_new_any(). A dict value
is dumped to JSON and a string value is passed as is. Since libyang v5,
libyang parses this string into the node content, so there is no value
type to give anymore.

An empty dict creates an empty node. Passing "{}" to libyang is not
safe: when the parsed tree is empty, libyang keeps our buffer as the
node value, but python still owns and frees it. A JSON string is
loaded first, so this also covers strings like "{ }".

Note that the default iter_children() types stay the same, so iterating
over a schema node still skips anydata and anyxml nodes.

Closes: #115
Signed-off-by: Stefan Gula <steweg@gmail.com>
Signed-off-by: Samuel Gauthier <samuel.gauthier@6wind.com>

Author: steweg

cffi/cdefs.h

@@ -894,6 +894,7 @@ LY_ERR lyd_new_term(struct lyd_node *, const struct lys_module *, const char *,
 char* lyd_path(const struct lyd_node *, LYD_PATH_TYPE, char *, size_t);
 LY_ERR lyd_new_inner(struct lyd_node *, const struct lys_module *, const char *, ly_bool, struct lyd_node **);
 LY_ERR lyd_new_list(struct lyd_node *, const struct lys_module *, const char *, uint32_t, struct lyd_node **node, ...);
+LY_ERR lyd_new_any(struct lyd_node *, const struct lys_module *, const char *, const struct lyd_node *, const char *, uint32_t, uint32_t, struct lyd_node **);
 
 struct lyd_node_inner {
     union {

libyang/data.py

@@ -2,13 +2,16 @@
 # Copyright (c) 2021 RACOM s.r.o.
 # SPDX-License-Identifier: MIT
 
+import json
 import logging
 from typing import IO, Any, Dict, Iterator, Optional, Tuple, Union
 
 from _libyang import ffi, lib
 from .keyed_list import KeyedList
 from .schema import (
     Module,
+    SAnydata,
+    SAnyxml,
     SContainer,
     SLeaf,
     SLeafList,
@@ -1319,6 +1322,55 @@ def _create_list(_parent, module, name, key_values, in_rpc_output=False):
         created.append(n[0])
         return n[0]
 
+    def _create_any(_parent, module, name, value, in_rpc_output=False):
+        # libyang parses a JSON or XML string into the anydata/anyxml content
+        if isinstance(value, str) and value.lstrip().startswith("{"):
+            value = json.loads(value)
+        if isinstance(value, dict):
+            # libyang keeps our buffer as the node value when the parsed
+            # tree is empty, so create an empty node instead
+            value = json.dumps(value) if value else None
+        elif not isinstance(value, str):
+            raise TypeError("%s: python value is not a dict/str: %r" % (name, value))
+
+        n = ffi.new("struct lyd_node **")
+        flags = newval_flags(rpc_output=in_rpc_output, store_only=store_only)
+        ret = lib.lyd_new_any(
+            _parent,
+            module.cdata,
+            str2c(name),
+            ffi.NULL,
+            str2c(value),
+            0,
+            flags,
+            n,
+        )
+        if ret != lib.LY_SUCCESS:
+            if _parent:
+                parent_path = repr(DNode.new(module.context, _parent).path())
+            else:
+                parent_path = "module %r" % module.name()
+            raise module.context.error(
+                "failed to create anydata/anyxml %r as a child of %s",
+                name,
+                parent_path,
+            )
+        created.append(n[0])
+
+    # same as the iter_children() defaults, plus anydata and anyxml
+    schema_types = (
+        SNode.ACTION,
+        SNode.CONTAINER,
+        SNode.LIST,
+        SNode.RPC,
+        SNode.LEAF,
+        SNode.LEAFLIST,
+        SNode.NOTIF,
+        SNode.CHOICE,
+        SNode.CASE,
+        SNode.ANYDATA,
+        SNode.ANYXML,
+    )
     schema_cache = {}
 
     def _find_schema(schema_parent, name, prefix):
@@ -1335,7 +1387,7 @@ def _find_schema(schema_parent, name, prefix):
             if schema_parent is None:
                 # there may not be any input or any output node in the rpc
                 return None, None
-        for s in schema_parent:
+        for s in schema_parent.children(types=schema_types):
             if s.name() != name:
                 continue
             mod = s.module()
@@ -1435,6 +1487,9 @@ def _to_dnode(_dic, _schema, _parent=ffi.NULL, in_rpc_output=False):
                 n = _create_container(_parent, module, name, in_rpc_output)
                 _to_dnode(value, s, n, in_rpc_output)
 
+            elif isinstance(s, (SAnydata, SAnyxml)):
+                _create_any(_parent, module, name, value, in_rpc_output)
+
     result = None
 
     try:

tests/test_data.py

@@ -11,6 +11,7 @@
 from _libyang import lib
 from libyang import (
     Context,
+    DAnydata,
     DAnyxml,
     DataType,
     DContainer,
@@ -1159,3 +1160,52 @@ def test_dnode_parse_json_null(self):
         dnode = self.ctx.parse_data_mem(JSON, "json", json_null=True)
         dnode_names = [d.name() for d in dnode.siblings()]
         self.assertFalse("ip-address" in dnode_names)
+
+    def test_dict_to_dnode_anydata(self):
+        module = self.ctx.load_module("yolo-nodetypes")
+        dic = {"yolo-nodetypes:any1": {"key1": "val1"}}
+        dnode = dict_to_dnode(dic, module, validate=False)
+        try:
+            self.assertIsInstance(dnode, DAnydata)
+            self.assertEqual(json.loads(dnode.value("json")), {"key1": "val1"})
+        finally:
+            dnode.free()
+
+    def test_dict_to_dnode_anydata_empty(self):
+        module = self.ctx.load_module("yolo-nodetypes")
+        for value in ({}, "{ }"):
+            dnode = dict_to_dnode(
+                {"yolo-nodetypes:any1": value}, module, validate=False
+            )
+            try:
+                self.assertIsInstance(dnode, DAnydata)
+                self.assertEqual(dnode.value("json"), None)
+            finally:
+                dnode.free()
+
+    def test_dict_to_dnode_anydata_rpc(self):
+        module = self.ctx.get_module("yolo-system")
+        dic = {"format-disk": {"disk": "sda", "json-info": {"key1": "val1"}}}
+        dnode = dict_to_dnode(dic, module, rpc=True)
+        try:
+            anydata = dnode.find_path("/yolo-system:format-disk/json-info")
+            self.assertIsInstance(anydata, DAnydata)
+            self.assertEqual(json.loads(anydata.value("json")), {"key1": "val1"})
+        finally:
+            dnode.free()
+
+    def test_dict_to_dnode_anyxml(self):
+        module = self.ctx.get_module("yolo-system")
+        dic = {"format-disk": {"html-info": "<p>text</p>"}}
+        dnode = dict_to_dnode(dic, module, rpc=True)
+        try:
+            anyxml = dnode.find_path("/yolo-system:format-disk/html-info")
+            self.assertIsInstance(anyxml, DAnyxml)
+            self.assertEqual(anyxml.value("xml").strip(), "<p>text</p>")
+        finally:
+            dnode.free()
+
+    def test_dict_to_dnode_anydata_bad_type(self):
+        module = self.ctx.load_module("yolo-nodetypes")
+        with self.assertRaises(TypeError):
+            dict_to_dnode({"yolo-nodetypes:any1": 42}, module, validate=False)