def test_client(self, mock_most): url = "http://localhost:9999/ws/hello" request = fixtures_dir.joinpath("hello/HelloRQ.xml").read_text() response = fixtures_dir.joinpath("hello/HelloRS.xml").read_bytes() headers = {"content-type": "text/xml"} mock_most.return_value = response config = Config.from_service(HelloGetHelloAsString) serializer = XmlSerializer(config=SerializerConfig(pretty_print=True)) client = Client(config=config, serializer=serializer) result = client.send( {"body": { "get_hello_as_string": { "arg0": "chris" } }}) self.assertIsInstance(result, HelloGetHelloAsString.output) body = HelloGetHelloAsStringOutput.Body( get_hello_as_string_response=GetHelloAsStringResponse( return_value="Hello chris")) self.assertEqual(body, result.body) mock_most.assert_called_once_with(url, data=request, headers=headers)
def test_client_with_soap_fault(self, mock_most): url = "http://localhost:9999/ws/hello" request = fixtures_dir.joinpath("hello/HelloRQ.xml").read_text() response = fixtures_dir.joinpath( "hello/HelloRS_SoapFault.xml").read_bytes() headers = {"content-type": "text/xml"} mock_most.return_value = response config = Config.from_service(HelloGetHelloAsString) serializer = XmlSerializer(config=SerializerConfig(pretty_print=True)) client = Client(config=config, serializer=serializer) result = client.send( {"body": { "get_hello_as_string": { "arg0": "chris" } }}) self.assertIsInstance(result, HelloGetHelloAsString.output) fault = HelloGetHelloAsStringOutput.Body.Fault( faultcode="S:Server", faultstring="foobar", detail=HelloGetHelloAsStringOutput.Body.Fault.Detail( hello_error=HelloError(message="foobar")), ) self.assertEqual(fault, result.body.fault) mock_most.assert_called_once_with(url, data=request, headers=headers)
def dumps(root_element, *, format=False) -> str: """Serialize a SDFormat object to an XML string. Parameters ---------- root_element : object An instance of ``skbot.ignition.models.vXX.Sdf``. XX represents the SDFormat version and can be any version currently supported by scikit-bot. format : bool If true, add indentation and linebreaks to the output to increase human readability. If false (default) the entire XML will appear as a single line with no spaces between elements. Returns ------- sdformat_string : str A string containing SDFormat XML representing the given input. Examples -------- .. minigallery:: skbot.ignition.sdformat.dumps """ serializer = XmlSerializer(config=SerializerConfig(pretty_print=format)) return serializer.render(root_element)
def validate_bindings(schema: Path, clazz: Type, output_format: str): __tracebackhide__ = True chapter = schema.stem.replace("chapter", "") sample = here.joinpath(f"samples/chapter{chapter}.xml") output_xml = here.joinpath(f"output/chapter{chapter}.xsdata.xml") output_json = here.joinpath(f"output/chapter{chapter}.xsdata.json") context = XmlContext(class_type=output_format) obj = XmlParser(context=context).from_path(sample, clazz) config = SerializerConfig(pretty_print=True) actual_json = JsonSerializer(context=context, config=config).render(obj) actual_xml = XmlSerializer(context=context, config=config).render(obj) if output_json.exists() and chapter != "13": assert output_json.read_text() == actual_json assert obj == JsonParser(context=context).from_string( actual_json, clazz) else: output_json.write_text(actual_json, encoding="utf-8") if output_xml.exists(): assert output_xml.read_text() == actual_xml else: output_xml.write_text(actual_xml, encoding="utf-8") validator = etree.XMLSchema(etree.parse(str(schema))) validator.assertValid(etree.fromstring(actual_xml.encode()))
def __init__(self, *, config: Configuration) -> None: self.config = config self.serializer = XmlSerializer(config=SerializerConfig( pretty_print=False)) self.parser = XmlParser(context=XmlContext()) self.requests: WeakValueDictionary[str, Future] = WeakValueDictionary({}) super().__init__()
def serialize(obj: object, pretty_print: bool = False) -> str: ns_map = __get_ns_map(obj) schema_location = __get_ns_schema_location(obj) config = SerializerConfig(xml_version='1.0', encoding='UTF-8', schema_location=schema_location, pretty_print=pretty_print) serializer = XmlSerializer(config=config) return serializer.render(obj, ns_map=ns_map)
def test_live(self): config = Config.from_service(HelloGetHelloAsString) serializer = XmlSerializer(config=SerializerConfig(pretty_print=True)) client = Client(config=config, serializer=serializer) result = client.send( {"body": { "get_hello_as_string": { "arg0": "chris" } }}) print(result)
def setUp(self) -> None: super().setUp() output = StringIO() config = SerializerConfig() self.writer = XmlWriter(output=output, config=config) self.writer.handler = XMLGenerator( output, encoding="UTF-8", short_empty_elements=True, )
def write(cls, output: TextIO, obj: "GeneratorConfig"): ctx = XmlContext( element_name_generator=text.pascal_case, attribute_name_generator=text.camel_case, ) config = SerializerConfig(pretty_print=True) serializer = XmlSerializer(context=ctx, config=config, writer=XmlEventWriter) serializer.write(output, obj, ns_map={None: "http://pypi.org/project/xsdata"})
def writer(xrnsfile, song): xrns = XrnsSerializer() xml_song = xrns.render(song) config = SerializerConfig(pretty_print=True, encoding="UTF-8", xml_version="1.0") serializer = XmlSerializer(config=config) # , writer=XmlEventWriter) rendered = serializer.render(xml_song) with zipfile.ZipFile(xrnsfile, mode="w") as zf: zf.writestr("Song.xml", rendered)
def test_client(self, mock_most): url = "http://www.dneonline.com/calculator.asmx" request = fixtures_dir.joinpath("calculator/AddRQ.xml").read_text() response = fixtures_dir.joinpath("calculator/AddRS.xml").read_bytes() headers = {"content-type": "text/xml", "SOAPAction": "http://tempuri.org/Add"} mock_most.return_value = response config = Config.from_service(CalculatorSoapAdd) serializer = XmlSerializer(config=SerializerConfig(pretty_print=True)) client = Client(config=config, serializer=serializer) result = client.send({"Body": {"Add": {"intA": 1, "intB": 3}}}) self.assertIsInstance(result, CalculatorSoapAddOutput) mock_most.assert_called_once_with(url, data=request, headers=headers)
def write_file_from_xml(xml_file_path: pathlib.Path, serialize_clazz: Optional[Type[T]]): """ Method to write serialized XML data to a file. :param xml_file_path: A pathlib.path path object that the data will write to. :param serialize_clazz: A class Object. :return: N/A """ serializer = XmlSerializer( config=SerializerConfig(pretty_print=True, encoding="UTF-8", xml_version="1.1", xml_declaration=False, schema_location="resources/xmltv.xsd", no_namespace_schema_location=None)) with xml_file_path.open("w") as data: serializer.write(data, serialize_clazz)
def __init_serializer( self, schema_location=None, no_namespace_schema_location=None ): """ Inits the internal serializer. Parameters ---------- schema_location: str Specify the xsi:schemaLocation attribute value no_namespace_schema_location: str Specify the xsi:noNamespaceSchemaLocation attribute value """ config = SerializerConfig( pretty_print=True, schema_location=schema_location, no_namespace_schema_location=no_namespace_schema_location, ) self.serializer = XmlSerializer(config=config)
def validate_bindings(schema: Path, clazz: Type): __tracebackhide__ = True obj = XmlParser().from_path(schema.with_suffix(".xml"), clazz) actual = JsonSerializer(indent=4).render(obj) expected = schema.with_suffix(".json") if expected.exists(): assert expected.read_text() == actual assert obj == JsonParser().from_string(actual, clazz) else: expected.write_text(actual, encoding="utf-8") config = SerializerConfig(pretty_print=True) xml = XmlSerializer(config=config).render(obj) validator = etree.XMLSchema(etree.parse(str(schema))) assert validator.validate(etree.fromstring( xml.encode())), validator.error_log expected.with_suffix(".xsdata.xml").write_text(xml, encoding="utf-8")
from xsdata.models.enums import Mode from xsdata.models.enums import Namespace from xsdata.models.enums import ProcessType from xsdata.models.enums import UseType from xsdata.models.mixins import array_any_element from xsdata.models.mixins import array_element from xsdata.models.mixins import attribute from xsdata.models.mixins import element from xsdata.models.mixins import ElementBase from xsdata.models.mixins import ModuleMixin from xsdata.utils import text from xsdata.utils.collections import unique_sequence from xsdata.utils.namespaces import clean_uri docstring_serializer = XmlSerializer( config=SerializerConfig(pretty_print=True, xml_declaration=False) ) DEFAULT_ATTR_NAME = "@value" @dataclass(frozen=True) class Docstring: class Meta: namespace = "http://www.w3.org/1999/xhtml" elements: Array[object] = array_any_element() @dataclass class Documentation(ElementBase):
def setUp(self): config = SerializerConfig(pretty_print=True) self.serializer = XmlSerializer(config=config, writer=LxmlEventWriter)
def to_xml(cls: Type[ME], obj: T) -> str: context = XmlContext(element_name_generator=str.upper) config = SerializerConfig(pretty_print=True) serializer = XmlSerializer(context=context, config=config) return serializer.render(obj)
import sys from pathlib import Path from xsdata.formats.dataclass.parsers import XmlParser from xsdata.formats.dataclass.serializers import XmlSerializer from xsdata.formats.dataclass.serializers.config import SerializerConfig from reqif.models import ReqIf here = Path(__file__).parent xml_fixture = here.joinpath("sample.xml") parser = XmlParser() config = SerializerConfig(pretty_print=True, encoding="ascii") serializer = XmlSerializer(context=parser.context, config=config) obj = parser.from_path(xml_fixture, ReqIf) ns_map = { None: "http://www.omg.org/spec/ReqIF/20110401/reqif.xsd", "xhtml": "http://www.w3.org/1999/xhtml", } serializer.write(sys.stdout, obj, ns_map=ns_map)
from xsdata.cli import cli from xsdata.formats.dataclass.context import XmlContext from xsdata.formats.dataclass.parsers import JsonParser from xsdata.formats.dataclass.parsers import XmlParser from xsdata.formats.dataclass.serializers import JsonSerializer from xsdata.formats.dataclass.serializers import XmlSerializer from xsdata.formats.dataclass.serializers.config import SerializerConfig from xsdata.utils import text from xsdata.utils.testing import load_class log = logging.getLogger() w3c = Path(__file__).absolute().parent.parent.joinpath("w3c") output = Path(__file__).absolute().parent.parent.joinpath("output/instances") os.chdir(w3c.parent) config = SerializerConfig(pretty_print=True) def assert_bindings( schema: str, instance: str, class_name: str, version: str, mode: str, save_output: bool, output_format: str, structure_style: str, ): __tracebackhide__ = True if mode == "xml":
def ToXML(header: ismrmrdHeader, encoding='ascii'): config = SerializerConfig(encoding=encoding, pretty_print=True) serializer = XmlSerializer(config) return serializer.render(header)
from xsdata.models.enums import FormType from xsdata.models.enums import Mode from xsdata.models.enums import Namespace from xsdata.models.enums import ProcessType from xsdata.models.enums import UseType from xsdata.models.mixins import array_any_element from xsdata.models.mixins import array_element from xsdata.models.mixins import attribute from xsdata.models.mixins import element from xsdata.models.mixins import ElementBase from xsdata.models.mixins import ModuleMixin from xsdata.utils import text from xsdata.utils.collections import unique_sequence from xsdata.utils.namespaces import clean_uri docstring_serializer = XmlSerializer(config=SerializerConfig( pretty_print=True)) @dataclass(frozen=True) class Docstring: elements: Array[object] = array_any_element() @dataclass class Documentation(ElementBase): """ Model representation of a schema xs:documentation element. :param lang: language :param source: anyURI :param elements: ({any})*
def serializer_config(): return SerializerConfig(pretty_print=True, ignore_default_attributes=True)