xsdata powered by Pydantic

https://xsdata-pydantic.readthedocs.io/en/latest/
Admin
xsData is a complete data binding library for Python allowing developers to access and use XML and...
Tokens:3,670
Snippets:36
Trust Score:9.6
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install xsdata-pydantic with Pip Extras

Source: https://xsdata-pydantic.readthedocs.io/en/latest/installation

Install xsdata-pydantic using pip with optional extras for CLI, lxml, and SOAP. The CLI extras are for the code generator, SOAP extras for the built-in WSDL client, and lxml for performance and advanced features.

```bash
pip install xsdata-pydantic[cli,lxml,soap]
```

--------------------------------

### Install xsdata-pydantic from Git Repository

Source: https://xsdata-pydantic.readthedocs.io/en/latest/installation

Install xsdata-pydantic directly from its GitHub repository using pip, including CLI and lxml extras.

```bash
pip install xsdata-pydantic[cli,lxml] @ git+https://github.com/tefra/xsdata-pydantic
```

--------------------------------

### xsdata Pydantic Configuration File Example

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

An example XML configuration file for xsdata, specifying Pydantic output settings, conventions, and substitutions for code generation.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<Config xmlns="http://pypi.org/project/xsdata" version="22.3">
  <Output maxLineLength="79">
    <Package>tests.fixtures.po.models</Package>
    <Format repr="true" eq="true" order="false" unsafeHash="false" frozen="false" slots="true" kwOnly="true">pydantic</Format>
    <Structure>single-package</Structure>
    <DocstringStyle>reStructuredText</DocstringStyle>
    <RelativeImports>false</RelativeImports>
    <CompoundFields defaultName="choice" forceDefaultName="false">false</CompoundFields>
    <PostponedAnnotations>false</PostponedAnnotations>
    <UnnestClasses>false</UnnestClasses>
  </Output>
  <Conventions>
    <ClassName case="pascalCase" safePrefix="type"/>
    <FieldName case="snakeCase" safePrefix="value"/>
    <ConstantName case="screamingSnakeCase" safePrefix="value"/>
    <ModuleName case="snakeCase" safePrefix="mod"/>
    <PackageName case="snakeCase" safePrefix="pkg"/>
  </Conventions>
  <Substitutions>
    <Substitution type="class" search="fooType" replace="Foo"/>
    <Substitution type="class" search="ABCSomething" replace="ABCSomething"/>
    <Substitution type="field" search="ChangeofGauge" replace="change_of_gauge"/>
    <Substitution type="package" search="http://www.w3.org/1999/xhtml" replace="xtml"/>
    <Substitution type="module" search="2010.1" replace="2020a"/>
  </Substitutions>
</Config>

```

--------------------------------

### Install xsdata-pydantic with Conda

Source: https://xsdata-pydantic.readthedocs.io/en/latest/installation

Install xsdata-pydantic using the conda package manager from the conda-forge channel.

```bash
conda install -c conda-forge xsdata-pydantic
```

--------------------------------

### Pydantic BaseModel for RSS Feed

Source: https://xsdata-pydantic.readthedocs.io/en/latest

This is an example of a pydantic BaseModel generated by xsdata for an RSS feed, including version and channel information.

```python
class Rss(BaseModel):
    class Meta:
        name = "rss"

    model_config = ConfigDict(defer_build=True)
    version: float = field(
        metadata={
            "type": "Attribute",
            "required": True,
        }
    )
    channel: Channel = field(
        metadata={
            "type": "Element",
            "required": True,
        }
    )

```

--------------------------------

### Generate Pydantic Models with Configuration File

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Generate Pydantic models using a configuration file to define output settings. This allows for more complex customization of the generated code.

```bash
$ xsdata tests/fixtures/schemas/po.xsd --config tests/fixtures/pydantic.conf.xml
Parsing schema po.xsd
Compiling schema po.xsd
Builder: 6 main and 1 inner classes
Analyzer input: 6 main and 1 inner classes
Analyzer output: 5 main and 1 inner classes
Generating package: init
Generating package: tests.fixtures.po.models

```

--------------------------------

### Import xsdata-pydantic Binding Shortcuts

Source: https://xsdata-pydantic.readthedocs.io/en/latest/bindings

Import various binding classes from xsdata_pydantic.bindings for convenient use with the attrs context already initialized. This includes parsers, serializers, and decoders/encoders.

```python
from xsdata_pydantic.bindings import XmlContext
from xsdata_pydantic.bindings import XmlParser
from xsdata_pydantic.bindings import XmlSerializer
from xsdata_pydantic.bindings import JsonParser
from xsdata_pydantic.bindings import JsonSerializer
from xsdata_pydantic.bindings import UserXmlParser
from xsdata_pydantic.bindings import TreeParser
from xsdata_pydantic.bindings import PycodeSerializer
from xsdata_pydantic.bindings import DictDecoder
from xsdata_pydantic.bindings import DictEncoder
```

--------------------------------

### Generate Pydantic Models from XML URL

Source: https://xsdata-pydantic.readthedocs.io/en/latest

Use the xsdata CLI to generate pydantic models from an XML URL and specify the output directory.

```bash
$ xsdata http://rss.cnn.com/rss/edition.rss --output pydantic
Parsing document edition.rss
Analyzer input: 9 main and 0 inner classes
Analyzer output: 9 main and 0 inner classes
Generating package: init
Generating package: generated.rss

```

--------------------------------

### Generate Pydantic Models from Schema

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Use the xsdata CLI to generate Pydantic models from an XSD schema. Specify 'pydantic' as the output format and provide the desired package name and structure style.

```bash
$ xsdata tests/fixtures/schemas/po.xsd --output pydantic --package tests.fixtures.po.models --structure-style single-package
Parsing schema po.xsd
Compiling schema po.xsd
Builder: 6 main and 1 inner classes
Analyzer input: 6 main and 1 inner classes
Analyzer output: 5 main and 1 inner classes
Generating package: init
Generating package: tests.fixtures.po.models

```

--------------------------------

### Load xsdata Plugin Before Using Models

Source: https://xsdata-pydantic.readthedocs.io/en/latest/issues

Ensure the xsdata plugin is loaded before using models to register custom validators for built-in types like XmlDuration. Importing a serializer or parser is sufficient to trigger the hook.

```python
from pydantic.dataclasses import dataclass
from xsdata.models.datatype import XmlDuration
# import serializer to trigger the xsdata hook to register the validators
from xsdata_pydantic.bindings import XmlSerializer

@dataclass
class DurationRangeMatcherType:
    begin: XmlDuration

print(DurationRangeMatcherType(begin=XmlDuration("PT3S")))
```

--------------------------------

### Generate Models with --unnest-classes Flag

Source: https://xsdata-pydantic.readthedocs.io/en/latest/issues

Use the --unnest-classes flag to move nested classes to the root level, resolving value or forward reference errors.

```bash
xsdata SOURCE --unnest-classes --output pydantic
```

--------------------------------

### Initialize XmlContext with Pydantic ClassType

Source: https://xsdata-pydantic.readthedocs.io/en/latest/bindings

Specify 'pydantic' as the class type for XmlContext to enable compatibility between dataclasses and pydantic models. This context is then used to initialize parsers and serializers.

```python
from xsdata.formats.dataclass.parsers import XmlParser
from xsdata.formats.dataclass.parsers import JsonParser
from xsdata.formats.dataclass.serializers import XmlSerializer
from xsdata.formats.dataclass.serializers import JsonSerializer
from xsdata.formats.dataclass.context import XmlContext

context = XmlContext(class_type="pydantic")  # Specify class type attrs
xml_parser = XmlParser(context=context)
xml_serializer = XmlSerializer(context=context)
json_parser = JsonParser(context=context)
json_serializer = JsonSerializer(context=context)
```

--------------------------------

### Define PurchaseOrder Pydantic Model

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Defines the root `PurchaseOrder` model, inheriting from `PurchaseOrderType`. It specifies the XML name and namespace for the root element. Uses `ConfigDict(defer_build=True)`.

```python
class PurchaseOrder(PurchaseOrderType):
    class Meta:
        name = "purchaseOrder"
        namespace = "foo"

    model_config = ConfigDict(defer_build=True)

```

--------------------------------

### Define PurchaseOrderType Pydantic Model

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Defines the base structure for a purchase order, including shipping and billing addresses, an optional comment, items, and an order date attribute. Uses `ConfigDict(defer_build=True)` for deferred model building.

```python
class PurchaseOrderType(BaseModel):
    model_config = ConfigDict(defer_build=True)
    ship_to: Usaddress = field(
        metadata={
            "name": "shipTo",
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    bill_to: Usaddress = field(
        metadata={
            "name": "billTo",
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    comment: Optional[Comment] = field(
        default=None,
        metadata={
            "type": "Element",
            "namespace": "foo",
        },
    )
    items: Items = field(
        metadata={
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    order_date: Optional[XmlDate] = field(
        default=None,
        metadata={
            "name": "orderDate",
            "type": "Attribute",
        },
    )
```

--------------------------------

### Parse XML Feed with xsdata and Pydantic

Source: https://xsdata-pydantic.readthedocs.io/en/latest

Use XmlParser from xsdata_pydantic to parse an XML feed from a URL into a pydantic model. Access specific elements like title, pub_date, and link.

```python
>>> from xsdata_pydantic.bindings import XmlParser
>>> from urllib.request import urlopen
>>> from generated.rss import Rss
>>> 
>>> parser = XmlParser()
>>> with urlopen("http://rss.cnn.com/rss/edition.rss") as rq:
...     result = parser.parse(rq, Rss)
...
>>> result.channel.item[2].title
'Vatican indicts 10 people, including a Cardinal, over an international financial scandal'
>>> result.channel.item[2].pub_date
'Sat, 03 Jul 2021 16:37:14 GMT'
>>> result.channel.item[2].link
'https://www.cnn.com/2021/07/03/europe/vatican-financial-scandal-intl/index.html'

```

--------------------------------

### Define Comment Pydantic Model

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Defines a simple Pydantic model for a comment, containing a single string value. It includes `ConfigDict(defer_build=True)` for deferred model building and specifies a default empty string value.

```python
class Comment(BaseModel):
    class Meta:
        name = "comment"
        namespace = "foo"

    model_config = ConfigDict(defer_build=True)
    value: str = field(
        default="",
        metadata={
            "required": True,
        },
    )
```

--------------------------------

### Define USAddress Pydantic Model

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Defines a Pydantic model for US address information, including elements like name, street, city, state, zip, and an attribute for country. Uses `ConfigDict(defer_build=True)` for deferred model building.

```python
from decimal import Decimal
from typing import List, Optional

from pydantic import BaseModel, ConfigDict
from xsdata.models.datatype import XmlDate

from xsdata_pydantic.fields import field

__NAMESPACE__ = "foo"


class Usaddress(BaseModel):
    class Meta:
        name = "USAddress"

    model_config = ConfigDict(defer_build=True)
    name: str = field(
        metadata={
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    street: str = field(
        metadata={
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    city: str = field(
        metadata={
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    state: str = field(
        metadata={
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    zip: Decimal = field(
        metadata={
            "type": "Element",
            "namespace": "foo",
            "required": True,
        }
    )
    country: str = field(
        const=True,
        default="US",
        metadata={
            "type": "Attribute",
        },
    )
```

--------------------------------

### Define Items Pydantic Model with Nested Item

Source: https://xsdata-pydantic.readthedocs.io/en/latest/codegen

Defines a Pydantic model for a collection of items, where each item has a product name, quantity, price, an optional comment, and a ship date. The `part_num` is a required attribute with a specific pattern. Uses `ConfigDict(defer_build=True)`.

```python
class Items(BaseModel):
    model_config = ConfigDict(defer_build=True)
    item: List["Items.Item"] = field(
        default_factory=list,
        metadata={
            "type": "Element",
            "namespace": "foo",
        },
    )

    class Item(BaseModel):
        model_config = ConfigDict(defer_build=True)
        product_name: str = field(
            metadata={
                "name": "productName",
                "type": "Element",
                "namespace": "foo",
                "required": True,
            }
        )
        quantity: int = field(
            metadata={
                "type": "Element",
                "namespace": "foo",
                "required": True,
                "max_exclusive": 100,
            }
        )
        usprice: Decimal = field(
            metadata={
                "name": "USPrice",
                "type": "Element",
                "namespace": "foo",
                "required": True,
            }
        )
        comment: Optional[Comment] = field(
            default=None,
            metadata={
                "type": "Element",
                "namespace": "foo",
            },
        )
        ship_date: Optional[XmlDate] = field(
            default=None,
            metadata={
                "name": "shipDate",
                "type": "Element",
                "namespace": "foo",
            },
        )
        part_num: str = field(
            metadata={
                "name": "partNum",
                "type": "Attribute",
                "required": True,
                "pattern": r"\d{3}-[A-Z]{2}",
            }
        )
```
Tokens:
Raw