Reorganize types.

yangson/context.py

@@ -21,30 +21,30 @@ class Context:
     ns_map = {} # type: Dict[YangIdentifier, YangIdentifier]
     """Map of module and submodule names to namespaces."""
 
-    features = set() # type: MutableSet[QName]
+    features = set() # type: MutableSet[QualName]
 
     @classmethod
-    def resolve_qname(cls, mid: ModuleId,
-                      qname: QName) -> Tuple[ModuleId, YangIdentifier]:
-        """Resolve prefix-based QName.
+    def resolve_pname(cls, pname: PrefName,
+                      mid: ModuleId) -> Tuple[YangIdentifier, ModuleId]:
+        """Resolve prefixed name.
 
+        :param pname: prefixed name
         :param mid: identifier of the context module
-        :param qname: qualified name in prefix form
         """
-        p, s, loc = qname.partition(":")
+        p, s, loc = pname.partition(":")
         try:
-            return (cls.prefix_map[mid][p], loc) if s else (mid, p)
+            return (loc, cls.prefix_map[mid][p]) if s else (p, mid)
         except KeyError:
-            raise BadQName(qname) from None
+            raise BadPrefName(pname) from None
 
     @classmethod
-    def translate_qname(cls, mid: ModuleId, qname: QName) -> NodeName:
-        """Translate prefix-based QName to an absolute name.
+    def translate_pname(cls, pname: PrefName, mid: ModuleId) -> QualName:
+        """Translate prefixed name to a qualified name.
 
+        :param qname: prefixed name
         :param mid: identifier of the context module
-        :param qname: qualified name in prefix form
         """
-        nid, loc = cls.resolve_qname(mid, qname)
+        loc, nid = cls.resolve_pname(pname, mid)
         return (loc, nid[0])
 
     @classmethod
@@ -55,7 +55,7 @@ class Context:
         :param sid: schema node identifier (absolute or relative)
         """
         nlist = sid.split("/")
-        return [ cls.translate_qname(mid, qn)
+        return [ cls.translate_pname(qn, mid)
                  for qn in (nlist[1:] if sid[0] == "/" else nlist) ]
 
     @classmethod
@@ -87,7 +87,7 @@ class Context:
         :param mid: YANG module context
         """
         kw = "grouping" if stmt.keyword == "uses" else "typedef"
-        did, loc = cls.resolve_qname(mid, stmt.argument)
+        loc, did = cls.resolve_pname(stmt.argument, mid)
         dstmt = (stmt.get_definition(loc, kw) if did == mid else
                  cls.modules[did].find1(kw, loc, required=True))
         return (dstmt, did)
@@ -101,8 +101,8 @@ class BadPath(YangsonException):
     def __str__(self) -> str:
         return self.path
 
-class BadQName(YangsonException):
-    """Exception to be raised for QName."""
+class BadPrefName(YangsonException):
+    """Exception to be raised for a broken prefixed name."""
 
     def __init__(self, qname: str) -> None:
         self.qname = qname

yangson/datamodel.py

@@ -33,7 +33,7 @@ class DataModel:
                 Context.ns_map[name] = name
                 if "feature" in item:
                     Context.features.update(
-                        [ name + ":" + f for f in item["feature"] ])
+                        [ (f,name) for f in item["feature"] ])
                 rev = item["revision"] if item["revision"] else None
                 mid = (name, rev)
                 ct = item["conformance-type"]

yangson/datatype.py

@@ -384,7 +384,7 @@ class IdentityrefType(DataType):
     def __init__(self) -> None:
         """Initialize the class instance."""
         super().__init__()
-        self.bases = [] # type: List[QName]
+        self.bases = [] # type: List[QualName]
 
     def handle_properties(self, stmt: Statement, mid: ModuleId) -> None:
         """Handle type substatements.
@@ -392,7 +392,8 @@ class IdentityrefType(DataType):
         :param stmt: YANG ``type identityref`` statement
         :param mid: id of the context module
         """
-        self.bases = [ b.argument for b in stmt.find_all("base") ]
+        self.bases = [ Context.translate_pname(b.argument, mid)
+                       for b in stmt.find_all("base") ]
 
 class NumericType(DataType):
     """Abstract class for numeric data types."""

yangson/instance.py

@@ -51,7 +51,7 @@ class ArrayValue(StructuredValue, list):
 
 class ObjectValue(StructuredValue, dict):
     """Array values corresponding to YANG container."""
-    def __init__(self, ts: datetime=None, val: Dict[QName, Value] = None):
+    def __init__(self, ts: datetime=None, val: Dict[MemName, Value] = None):
         StructuredValue.__init__(self, ts)
         if val is not None:
             dict.__init__(self, val)
@@ -87,8 +87,8 @@ class Crumb:
 class MemberCrumb(Crumb):
     """Zipper contexts for an object member."""
 
-    def __init__(self, name: QName, obj: Dict[QName, Value], parent: Crumb,
-                 ts: datetime = None) -> None:
+    def __init__(self, name: MemName, obj: Dict[MemName, Value],
+                 parent: Crumb, ts: datetime = None) -> None:
         """Initialize the class instance.
 
         :param name: name of an object member that's the current focus
@@ -100,7 +100,7 @@ class MemberCrumb(Crumb):
         self.name = name
         self.object = obj
 
-    def pointer_fragment(self) -> QName:
+    def pointer_fragment(self) -> MemName:
         """Return the JSON pointer fragment of the focused value."""
         return self.name
 
@@ -217,7 +217,7 @@ class Instance:
             inst = inst.up()
         return inst
 
-    def member(self, name: QName) -> "Instance":
+    def member(self, name: MemName) -> "Instance":
         try:
             obj = self.value.copy()
             return Instance(obj.pop(name), MemberCrumb(name, obj, self.crumb))
@@ -226,7 +226,7 @@ class Instance:
         except KeyError:
             raise NonexistentInstance(self, "member " + name) from None
 
-    def new_member(self, name: QName, value: Value) -> "Instance":
+    def new_member(self, name: MemName, value: Value) -> "Instance":
         if not isinstance(self.value, ObjectValue):
             raise InstanceTypeError(self, "member of non-object")
         if name in self.value:
@@ -234,7 +234,7 @@ class Instance:
         return Instance(value, MemberCrumb(name, self.value, self.crumb,
                                            datetime.now()))
 
-    def remove_member(self, name: QName) -> "Instance":
+    def remove_member(self, name: MemName) -> "Instance":
         try:
             val = self.value.copy()
             del val[name]
@@ -244,7 +244,7 @@ class Instance:
         except KeyError:
             raise NonexistentInstance(self, "member " + name) from None
 
-    def sibling(self, name: QName) -> "Instance":
+    def sibling(self, name: MemName) -> "Instance":
         try:
             obj = self.crumb.object.copy()
             newval = obj.pop(name)
@@ -293,7 +293,7 @@ class Instance:
         except IndexError:
             raise NonexistentInstance(self, "last of empty") from None
 
-    def look_up(self, keys: Dict[QName, ScalarValue]) -> "Instance":
+    def look_up(self, keys: Dict[MemName, ScalarValue]) -> "Instance":
         """Return the entry with matching keys."""
         if not isinstance(self.value, ArrayValue):
             raise InstanceTypeError(self, "lookup on non-list")
@@ -366,7 +366,7 @@ class InstanceSelector:
 class MemberName(InstanceSelector):
     """Selectors of object members."""
 
-    def __init__(self, name: QName) -> None:
+    def __init__(self, name: MemName) -> None:
         """Initialize the class instance.
 
         :param name: member name
@@ -469,7 +469,7 @@ class EntryValue(InstanceSelector):
 class EntryKeys(InstanceSelector):
     """Key-based selectors for a list entry."""
 
-    def __init__(self, keys: Dict[QName, ScalarValue]) -> None:
+    def __init__(self, keys: Dict[MemName, ScalarValue]) -> None:
         """Initialize the class instance.
 
         :param keys: dictionary with keys of an entry
@@ -538,7 +538,7 @@ class InstanceTypeError(InstanceError):
 class DuplicateMember(InstanceError):
     """Exception to raise on attempt to create a member that already exists."""
 
-    def __init__(self, inst: Instance, name: QName) -> None:
+    def __init__(self, inst: Instance, name: MemName) -> None:
         super().__init__(inst)
         self.name = name
 

yangson/schema.py

@@ -11,7 +11,7 @@ from .statement import Statement
 from .typealiases import *
 
 # Local type aliases
-RawObject = Dict[QName, "RawValue"]
+RawObject = Dict[MemName, "RawValue"]
 RawList = List["RawObject"]
 RawLeafList = List["RawScalar"]
 RawValue = Union[RawScalar, RawObject, RawList, RawLeafList]
@@ -34,14 +34,14 @@ class SchemaNode:
             return self.parent.config
 
     @property
-    def qname(self) -> QName:
-        """Return qualified name of the receiver."""
+    def qname(self) -> MemName:
+        """Return member name of a receiver instance."""
         return (self.name if self.ns == self.parent.ns
                 else self.ns + ":" + self.name)
 
     @staticmethod
-    def unqname(qn: QName) -> Tuple[YangIdentifier, Optional[YangIdentifier]]:
-        """Translate qualified name to (name, namespace) tuple.
+    def unqname(qn: MemName) -> Tuple[YangIdentifier, Optional[YangIdentifier]]:
+        """Translate member name to a qualified tuple.
 
         :param qn: qualified name
         """
@@ -401,7 +401,7 @@ class ListNode(InternalNode, DataNode):
     def __init__(self) -> None:
         """Initialize the class instance."""
         super().__init__()
-        self.keys = [] # type: List[NodeName]
+        self.keys = [] # type: List[QualName]
         self.min_elements = 0 # type: int
         self.max_elements = None # type: Optional[int]
 
@@ -409,7 +409,7 @@ class ListNode(InternalNode, DataNode):
         kst = stmt.find1("key")
         if kst is None: return
         self.keys = [
-            Context.translate_qname(mid, k) for k in kst.argument.split() ]
+            Context.translate_pname(k, mid) for k in kst.argument.split() ]
 
     def leaf_stmt(self, stmt: Statement, mid: ModuleId) -> None:
         """Handle leaf statement."""
@@ -483,7 +483,7 @@ class ChoiceNode(InternalNode):
     def __init__(self) -> None:
         """Initialize the class instance."""
         super().__init__()
-        self.default = None # type: NodeName
+        self.default = None # type: QualName
         self.mandatory = False # type: bool
 
     def _tree_line_prefix(self) -> str:
@@ -507,7 +507,7 @@ class ChoiceNode(InternalNode):
             cn.handle_child(node, stmt, mid)
 
     def default_stmt(self, stmt: Statement, mid: ModuleId) -> None:
-        self.default = Context.translate_qname(mid, stmt.argument)
+        self.default = Context.translate_pname(stmt.argument, mid)
 
     def tree_line(self) -> str:
         """Return the receiver's contribution to tree diagram."""

yangson/typealiases.py

@@ -6,8 +6,9 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 RevisionDate = Optional[str]
 Uri = str
 YangIdentifier = str
-QName = str # [YangIdentifier:]YangIdentifier
+MemName = str # [YangIdentifier:]YangIdentifier
+PrefName = str # [Prefix:]YangIdentifier
 ScalarValue = Union[int, Decimal, str]
-NodeName = Tuple[YangIdentifier, YangIdentifier] # (name, namespace)
-SchemaAddress = List[NodeName]
+QualName = Tuple[YangIdentifier, YangIdentifier] # (name, namespace)
+SchemaAddress = List[QualName]
 ModuleId = Tuple[YangIdentifier, Optional[RevisionDate]]