How to use the aioxmpp.xso.XSO function in aioxmpp

def test_unparse_to_node_handle_child(self):
        class ClsLeaf(xso.XSO):
            TAG = "baz"
            text = xso.Text()

        class Cls(xso.XSO):
            TAG = "bar"
            child = xso.Child([ClsLeaf])

        obj = Cls()
        obj.child = ClsLeaf()
        obj.child.text = "fnord"

        self._unparse_test(
            obj,
            etree.fromstring("fnord")
        )

def test__register(self):
        class ClsLeaf2(xso.XSO):
            TAG = "baz"

        self.ClsA.test_child._register(ClsLeaf2)
        self.assertDictEqual(
            {
                (None, "bar"): self.ClsLeaf,
                (None, "baz"): ClsLeaf2
            },
            self.ClsA.test_child.get_tag_map()
        )

        class ClsLeafConflict(xso.XSO):
            TAG = "baz"

        with self.assertRaisesRegexp(ValueError, "ambiguous children"):
            self.ClsA.test_child._register(ClsLeafConflict)

########################################################################
import unittest

import aioxmpp
import aioxmpp.private_xml.service as private_xml_service
import aioxmpp.private_xml.xso as private_xml_xso

from aioxmpp.testutils import (
    make_connected_client,
    CoroutineMock,
    run_coroutine,
)


@private_xml_xso.Query.as_payload_class
class FakePayload(aioxmpp.xso.XSO):
    TAG = "tests/private_xml/test_service.py", "payload"


class TestService(unittest.TestCase):

    def setUp(self):
        self.cc = make_connected_client()
        self.s = private_xml_service.PrivateXMLService(
            self.cc,
            dependencies={},
        )
        self.cc.mock_calls.clear()

    def tearDown(self):
        del self.cc
        del self.s

# License along with this program.  If not, see
# .
#
########################################################################
import contextlib
import unittest
import unittest.mock

import aioxmpp.private_xml.xso as private_xml_xso
import aioxmpp.xso as xso

from aioxmpp.utils import namespaces


@private_xml_xso.Query.as_payload_class
class FakePayload(xso.XSO):
    TAG = "tests/private_xml/test_xso.py", "payload"


class TestQuery(unittest.TestCase):

    def test_namespace(self):
        self.assertEqual(
            namespaces.xep0049,
            "jabber:iq:private"
        )

    def test_is_xso(self):
        self.assertTrue(issubclass(private_xml_xso.Query, xso.XSO))

    def test_tag(self):
        self.assertEqual(

import unittest

import aioxmpp.pep
import aioxmpp.xso as xso
import aioxmpp.pubsub.xso as pubsub_xso

from aioxmpp.e2etest import (
    blocking,
    blocking_timed,
    require_identity,
    TestCase
)


@pubsub_xso.as_payload_class
class ExamplePayload(xso.XSO):
    TAG = ("urn:example:payload", "payload")
    data = xso.Text()


EXAMPLE_TEXT = "Though this be madness, yet there is method in't"


class TestPEP(TestCase):
    @require_identity("pubsub", "pep")
    @blocking
    @asyncio.coroutine
    def setUp(self, _):
        self.client = yield from self.provisioner.get_connected_client(
            services=[
                aioxmpp.PresenceServer,
                aioxmpp.pep.PEPClient

results = []

        def recv(obj):
            nonlocal results
            results.append(obj)

        class Bar(xso.XSO):
            TAG = ("uri:foo", "bar")

            text = xso.Text(default=None)

            def __init__(self, text=None):
                super().__init__()
                self.text = text

        class Baz(xso.XSO):
            TAG = ("uri:foo", "baz")

            children = xso.ChildList([Bar])

        class Foo(xso.XSO):
            TAG = ("uri:foo", "foo")

            attr = xso.Attr((None, "attr"))
            bar = xso.Child([Bar])
            baz = xso.Child([Baz])

        self.proc.stanza_parser = xso.XSOParser()
        self.proc.stanza_parser.add_class(Foo, recv)

        self.proc.startDocument()
        self.proc.startElementNS(self.STREAM_HEADER_TAG, None,

def test_is_xso(self):
        self.assertTrue(issubclass(
            misc_xso.JSONContainer,
            xso.XSO,
        ))

def __init__(self,
                 condition,
                 text=None,
                 application_defined_condition=None):
        if not isinstance(condition, (ErrorCondition, xso.XSO)):
            condition = ErrorCondition(condition)
            warnings.warn(
                "as of aioxmpp 1.0, error conditions must be members of the "
                "aioxmpp.ErrorCondition enumeration",
                DeprecationWarning,
                stacklevel=2,
            )

        super().__init__(format_error_text(
            condition.enum_member,
            text=text,
            application_defined_condition=application_defined_condition))
        self.condition_obj = condition.to_xso()
        self.text = text
        self.application_defined_condition = application_defined_condition

This attribute is either an instance of :class:`Required` or
       :data:`None`. The former indicates that the server requires resource
       binding at this point in the stream negotation; :data:`None` indicates
       that it is not required.

       User code should just test the boolean value of this attribute and not
       worry about the actual types involved.

    """
    TAG = (namespaces.rfc6120_bind, "bind")

    required = xso.Child([Required], required=False)


class Bind(xso.XSO):
    """
    The :class:`.IQ` payload for binding to a resource.

    .. attribute:: jid

       The server-supplied :class:`aioxmpp.JID`. This must not be set by
       client code.

    .. attribute:: resource

       The client-supplied, optional resource. If a client wishes to bind to a
       specific resource, it must tell the server that using this attribute.

    """

    TAG = (namespaces.rfc6120_bind, "bind")

])


class EventRedirect(xso.XSO):
    TAG = (namespaces.xep0060_event, "redirect")

    uri = xso.Attr(
        "uri",
    )

    def __init__(self, uri):
        super().__init__()
        self.uri = uri


class EventDelete(xso.XSO):
    TAG = (namespaces.xep0060_event, "delete")

    _redirect = xso.Child([
        EventRedirect,
    ])

    node = xso.Attr(
        "node",
    )

    def __init__(self, node, *, redirect_uri=None):
        super().__init__()
        self.node = node
        if redirect_uri is not None:
            self._redirect = EventRedirect(redirect_uri)