Only raise NotImplementedError in abstract classes

Raising NotImplementedError states that a method is abstract and should
be implemented in subclasses. This causes pylint errors when subclassing
KeyedList:

  Method 'not_implemented' is abstract in class 'KeyedList' but is not
  overridden [abstract-method]

Raise TypeError for unsupported operations in KeyedList and for
unsupported schema/data node types.

Signed-off-by: Robin Jarry <robin.jarry@6wind.com>

Author: rjarry

libyang/data.py

@@ -595,9 +595,7 @@ def new(cls, context: "libyang.Context", cdata) -> "DNode":
         cdata = ffi.cast("struct lyd_node *", cdata)
         nodecls = cls.NODETYPE_CLASS.get(cdata.schema.nodetype, None)
         if nodecls is None:
-            raise NotImplementedError(
-                "node type %s not implemented" % cdata.schema.nodetype
-            )
+            raise TypeError("node type %s not implemented" % cdata.schema.nodetype)
         return nodecls(context, cdata)
 
 

libyang/keyed_list.py

@@ -69,7 +69,7 @@ def extend(self, iterable: Iterable) -> None:
 
     def pop(self, key: ListKeyVal = None, default: Any = None) -> Any:
         if key is None or isinstance(key, (int, slice)):
-            raise NotImplementedError("non-ordered lists cannot be accessed by index")
+            raise TypeError("non-ordered lists cannot be accessed by index")
         return self._map.pop(key, default)
 
     def remove(self, element: Any) -> None:
@@ -78,12 +78,12 @@ def remove(self, element: Any) -> None:
 
     def __getitem__(self, key: ListKeyVal) -> Any:
         if isinstance(key, (int, slice)):
-            raise NotImplementedError("non-ordered lists cannot be accessed by index")
+            raise TypeError("non-ordered lists cannot be accessed by index")
         return self._map[key]
 
     def __delitem__(self, key: ListKeyVal) -> None:
         if isinstance(key, (int, slice)):
-            raise NotImplementedError("non-ordered lists cannot be accessed by index")
+            raise TypeError("non-ordered lists cannot be accessed by index")
         del self._map[key]
 
     def __eq__(self, other: Any) -> bool:
@@ -140,24 +140,24 @@ def __deepcopy__(self, memo) -> "KeyedList":
         return k
 
     # unsupported list API methods
-    def not_implemented(self, *args, **kwargs):
-        raise NotImplementedError()
-
-    index = not_implemented
-    insert = not_implemented
-    reverse = not_implemented
-    sort = not_implemented
-    __add__ = not_implemented
-    __ge__ = not_implemented
-    __gt__ = not_implemented
-    __iadd__ = not_implemented
-    __imul__ = not_implemented
-    __le__ = not_implemented
-    __lt__ = not_implemented
-    __mul__ = not_implemented
-    __reversed__ = not_implemented
-    __rmul__ = not_implemented
-    __setitem__ = not_implemented
+    def __unsupported(self, *args, **kwargs):
+        raise TypeError("unsupported operation for non-ordered lists")
+
+    index = __unsupported
+    insert = __unsupported
+    reverse = __unsupported
+    sort = __unsupported
+    __add__ = __unsupported
+    __ge__ = __unsupported
+    __gt__ = __unsupported
+    __iadd__ = __unsupported
+    __imul__ = __unsupported
+    __le__ = __unsupported
+    __lt__ = __unsupported
+    __mul__ = __unsupported
+    __reversed__ = __unsupported
+    __rmul__ = __unsupported
+    __setitem__ = __unsupported
 
 
 # -------------------------------------------------------------------------------------

libyang/schema.py

@@ -862,7 +862,7 @@ def new(context: "libyang.Context", cdata) -> "SNode":
         cdata = ffi.cast("struct lys_node *", cdata)
         nodecls = SNode.NODETYPE_CLASS.get(cdata.nodetype, None)
         if nodecls is None:
-            raise NotImplementedError("node type %s not implemented" % cdata.nodetype)
+            raise TypeError("node type %s not implemented" % cdata.nodetype)
         return nodecls(context, cdata)
 
 

tests/test_keyedlist.py

@@ -10,23 +10,23 @@
 class KeyedListTest(unittest.TestCase):
     def test_keylist_base(self):
         l = ly.KeyedList(["x"])
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l.index("x")
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l.insert(0, "x")
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l.reverse()
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l.sort()
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l["x"] = 2
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l[0]  # pylint: disable=pointless-statement
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             del l[0]
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l.pop()
-        with self.assertRaises(NotImplementedError):
+        with self.assertRaises(TypeError):
             l.pop(0)
 
     def test_keylist_leaflist(self):