ncclient:NETCONF Python client

from weakref import WeakKeyDictionary

from listener import SessionListener

from ncclient.content.builders import RPCBuilder

from ncclient.content.parsers import RPCReplyParser

_listeners = WeakKeyDictionary()

_lock = Lock()

def get_listener(session):

    with self._lock:

        return _listeners.setdefault(session, ReplyListener())

    def __init__(self, session):

        self._id = None

        self._reply = None # RPCReply

        self._reply_event = None

    @property

        self._id = uuid1().urn

class RPCReply:

    def __init__(self, event):

        self._delivery_event = event

        self._raw = None

        self._errs = None

    def __str__(self):

        return self._raw

    def parse(self):

        if not self._parsed:

            errs = RPCReplyParser.parse(self._raw)

            for raw, err_dict in errs:

                self._errs.append(RPCError(raw, err_dict))

            self._parsed = True

    def deliver(self, raw):

        self._raw = raw

        self._delivery_event.set()

    def received(self, timeout=None):

        self._delivery_event.wait(timeout)

        return True

    @property

    def raw(self):

        return self._raw

    @property

    def parsed(self):

        return self._parsed

    @property

    def ok(self):

        return True if self._parsed and not self._errs else False

    @property

    def errors(self):

        return self._errs

class RPCError(Exception): # raise it if you like

    def __init__(self, raw, err_dict):

        self._raw = raw

        self._dict = err_dict

    def __str__(self):

        # TODO

        return self._raw

    def __dict__(self):

        return self._dict

    @property

    def raw(self):

        return self._raw

    @property

    def type(self):

        return self._dict.get('type', None)

    @property

    def severity(self):

        return self._dict.get('severity', None)

    @property

    def tag(self):

        return self._dict.get('tag', None)

    @property

    def path(self):

        return self._dict.get('path', None)

    @property

    def message(self):

        return self._dict.get('message', None)

    @property

    def info(self):

        return self._dict.get('info', None)

class Notification:

    pass

from builder import TreeBuilder

from common import BASE_NS

from common import qualify as _

################################################################################

_ = qualify

def build(msgid, op, encoding='utf-8'):

    "TODO: docstring"

    if isinstance(op, basestring):

        return RPCBuilder.build_from_string(msgid, op, encoding)

    else:

        return RPCBuilder.build_from_spec(msgid, op, encoding)

def build_from_spec(msgid, opspec, encoding='utf-8'):

    "TODO: docstring"

    spec = {

        'tag': _('rpc', BASE_NS),

        'attributes': {'message-id': msgid},

        'children': opspec

        }

    return TreeBuilder(spec).to_string(encoding)

def build_from_string(msgid, opstr, encoding='utf-8'):

    "TODO: docstring"

    decl = '<?xml version="1.0" encoding="%s"?>' % encoding

    doc = (u'''<rpc message-id="%s" xmlns="%s">%s</rpc>''' %

           (msgid, BASE_NS, opstr)).encode(encoding)

    return (decl + doc)

################################################################################

# parsing stuff TODO