/ - Diff - ncclient:NETCONF Python client - Greek Research and Technology Network's projects

         def request(self, target, config, default_operation=None, test_option=None,
                     error_option=None):
             """
             :arg target: see :ref:`source_target`
             :type target: string
             :arg config: a config element in :ref:`dtree`
             :type config: `string` or `dict` or :class:`~xml.etree.ElementTree.Element`
             :arg default_operation: optional; one of {'merge', 'replace', 'none'}
             :type default_operation: `string`
             :arg error_option: optional; one of {'stop-on-error', 'continue-on-error', 'rollback-on-error'}. Last option depends on the *:rollback-on-error* capability
             :type error_option: string
             :arg test_option: optional; one of {'test-then-set', 'set'}. Depends on *:validate* capability.
             :type test_option: string
             :seealso: :ref:`return`
             """
             #:arg default_operation: optional; one of {'merge', 'replace', 'none'}
             #:type default_operation: `string`
+            #
             #:arg error_option: optional; one of {'stop-on-error', 'continue-on-error', 'rollback-on-error'}. Last option depends on the *:rollback-on-error* capability
             #:type error_option: string
+            #
             #:arg test_option: optional; one of {'test-then-set', 'set'}. Depends on *:validate* capability.
             #:type test_option: string
             node = new_ele("edit-config")
             node.append(util.datastore_or_url("target", target, self._assert))
             if error_option is not None:
-...
         "*<delete-config>* RPC"
         def request(self, target):
             """
             :arg target: See :ref:`source_target`
             :type target: `string` or `dict` or :class:`~xml.etree.ElementTree.Element`
             :seealso: :ref:`return`
             """
             node = new_ele("delete-config")
             node.append(util.datastore_or_url("target", target, self._assert))
             return self._request(spec)
-...
         "*<copy-config>* RPC"
         def request(self, source, target):
             """
             :arg source: See :ref:`source_target`
             :type source: `string` or `dict` or :class:`~xml.etree.ElementTree.Element`
             :arg target: See :ref:`source_target`
             :type target: `string` or `dict` or :class:`~xml.etree.ElementTree.Element`
             :seealso: :ref:`return`
             """
             node = new_ele("copy-config")
             node.append(util.datastore_or_url("target", target, self._assert))
             node.append(util.datastore_or_url("source", source, self._assert))
-...
         DEPENDS = [':validate']
         def request(self, source):
             """
             :arg source: See :ref:`source_target`
             :type source: `string` or `dict` or :class:`~xml.etree.ElementTree.Element`
             :seealso: :ref:`return`
             """
             node = new_ele("validate")
             try:
                 src = validated_element(source, ("config", qualify("config")))
-...
             """
             Requires *:confirmed-commit* capability if *confirmed* argument is
             :const:`True`.
             :arg confirmed: optional; request a confirmed commit
             :type confirmed: `bool`
             :arg timeout: specify timeout for confirmed commit
             :type timeout: `int`
             :seealso: :ref:`return`
             """
             #:arg confirmed: optional; request a confirmed commit
             #:type confirmed: `bool`
+            #
             #:arg timeout: specify timeout for confirmed commit
             #:type timeout: `int`
             node = new_ele("commit")
             if confirmed:
                 self._assert(":confirmed-commit")
-...
         DEPENDS = [":candidate"]
         def request(self):
             ":seealso: :ref:`return`"
             return self._request(new_ele("discard-changes"))

         "*<lock>* RPC"
         def request(self, target):
             """
             :arg target: see :ref:`source_target`
             :type target: string
             :rtype: :ref:`return`
             """
             node = new_ele("lock")
             sub_ele(sub_ele(node, "target"), "running")
             return self._request(node)
-...
         "*<unlock>* RPC"
         def request(self, target):
             """
             :arg target: see :ref:`source_target`
             :type target: string
             :rtype: :ref:`return`
             """
             node = new_ele("unlock")
             sub_ele(sub_ele(node, "target"), "running")
             return self._request(node)
-...
         RPC errors are always raised as exceptions.
         Initialise with session instance (:class:`Session
         <ncclient.transport.Session>`) and lock target (:ref:`source_target`)
         Initialise with (:class:`Session <ncclient.transport.Session>`) instance
         and lock target.
         """
         def __init__(self, session, target):

         REPLY_CLS = GetReply
         def request(self, filter=None):
             """
             :arg filter: optional; see :ref:`filter`
             :seealso: :ref:`return`
             """
             node = new_ele("get")
             if filter is not None:
                 node.append(util.build_filter(filter))
-...
         REPLY_CLS = GetReply
         def request(self, source, filter=None):
             """
             :arg source: See :ref:`source_target`
             :arg filter: optional; see :ref:`filter`
             :seealso: :ref:`return`
             """
             node = new_ele("get-config")
             node.append(util.datastore_or_url("source", source, self._assert))
             if filter is not None:

             object. The :attr:`event` attribute will be set when the reply has been
             received (see :attr:`reply`) or an error occured (see :attr:`error`).
             :arg opspec: :ref:`dtree` for the operation
             :type opspec: :obj:`dict` or :obj:`string` or :class:`~xml.etree.ElementTree.Element`
             :rtype: :class:`RPCReply` (sync) or :class:`RPC` (async)
             """
-...
                     raise TimeoutExpiredError
         def request(self, *args, **kwds):
             """Subclasses implement this method. Here, the operation is constructed
             in :ref:`dtree`, and the result of :meth:`_request` returned."""
             "Subclasses implement this method."
             return self._request(self.SPEC)
         def _assert(self, capability):

             """
             :arg session_id: *session-id* of NETCONF session to kill
             :type session_id: `string`
             :seealso: :ref:`return`
             """
             node = new_ele("kill-session")
             if not isinstance(session_id, basestring): # make sure

             the publickey authentication method and then password authentication.
             To disable attemting publickey authentication altogether, call with
             *allow_agent* and *look_for_keys* as :const:`False`. This may be needed
             for Cisco devices which immediately disconnect on an incorrect
             authentication attempt.
             *allow_agent* and *look_for_keys* as :const:`False`.
             :arg host: the hostname or IP address to connect to
             :type host: `string`

     # limitations under the License.
     """The :mod:`xml` module provides methods for creating XML documents, parsing
     XML, and converting between different XML representations. It uses
     :mod:`~xml.etree.ElementTree` internally.
     """
     """The :mod:`xml_` module provides methods for creating, parsing, and dealing
     with XML. It uses :mod:`~xml.etree.ElementTree`."""
     from cStringIO import StringIO
     from xml.etree import cElementTree as ET
-...
     #: Base NETCONF namespace
     BASE_NS_1_0 = 'urn:ietf:params:xml:ns:netconf:base:1.0'
     #: namespace for Tail-f data model
     #: Namespace for Tail-f core data model
     TAILF_AAA_1_1 = 'http://tail-f.com/ns/aaa/1.1'
     #: namespace for Tail-f data model
     #: Namespace for Tail-f execd data model
     TAILF_EXECD_1_1 = 'http://tail-f.com/ns/execd/1.1'
     #: namespace for Cisco data model
     #: Namespace for Cisco data model
     CISCO_CPI_1_0 = 'http://www.cisco.com/cpi_10/schema'
     #: namespace for Flowmon data model
     #: Namespace for Flowmon data model
     FLOWMON_1_0 = 'http://www.liberouter.org/ns/netopeer/flowmon/1.0'
     try:
-...
     #unqualify = lambda tag: tag[tag.rfind('}')+1:]
     def to_xml(ele, encoding="UTF-8"):
         """Element -> XML
         """Convert an :class:`~xml.etree.ElementTree.Element` to XML.
         :type spec: :class:`~xml.etree.ElementTree.Element`
         :arg ele: the :class:`~xml.etree.ElementTree.Element`
         :arg encoding: character encoding
         :rtype: :obj:`string`
         """
-...
         return xml if xml.startswith('<?xml') else '<?xml version="1.0" encoding="%s"?>%s' % (encoding, xml)
     def to_ele(x):
         """XML -> Element
         """Convert XML to :class:`~xml.etree.ElementTree.Element`.
         :type xml: :obj:`string`
         :rtype: :class:`~xml.etree.ElementTree.Element`
-...
         """Efficiently parses the root element of an XML document.
         :arg raw: XML document
         :type raw: string
         :returns: a tuple of `(tag, attributes)`, where `tag` is the (qualified) name of the element and `attributes` is a dictionary of its attributes.
         :returns: a tuple of `(tag, attrib)`, where *tag* is the (qualified)
         name of the element and *attrib* is a dictionary of its attributes.
         :rtype: `tuple`
         """
         fp = StringIO(raw)
-...
             return (element.tag, element.attrib)
     def validated_element(x, tags=None, attrs=None):
         """Checks if the root element meets the supplied criteria. Returns a
         :class:`~xml.etree.ElementTree.Element` instance if so, otherwise raises
         :exc:`ContentError`.
         """Checks if the root element of an XML document or
         :class:`~xml.etree.ElementTree.Element` meets the supplied criteria. Raises
         :exc:`XMLError` if it is not met.
         :arg x: the XML document or :class:`~xml.etree.ElementTree.Element` to validate
         :arg tags: tag name or a sequence of allowable tag names
         :arg attrs: sequence of required attribute names, each item may be a list of allowable alternatives
         :arg text: textual content to match
         :type rep: :class:`~xml.etree.ElementTree.Element`
         :returns: validated element
         :rtype: :class:`~xml.etree.ElementTree.Element`
         """
         ele = to_ele(x)
         if tags:

ncclient:NETCONF Python client

Revision dd8b8dd7