How can alias in pydantic model be preserved?

[impaktor]

Hi!

I note in documentation for pydantic models, there's a use_alias, however, it's not clear to me how to use it, as it seems to be an argument to some internal method?

My use case is to generate new XML files with new random content. I can read in an XML file, parse it to a dict, parse it into a pydantic model, store it back as XML, however, if I generate new model object using polyfactory, the naming convention of the field breaks, as e.g. attribute fields need to be prefixed by "@", which requires use of alias in pydantic.

In case it's needed, I provide a small toy example below:

Example code

from pprint import pprint

import xmltodict
from polyfactory.factories.pydantic_factory import ModelFactory
from pydantic import BaseModel, Field

# Define some xml, that's a mix of attribute values, and child elements
xml_data = """<?xml version="1.0" encoding="iso-8859-1"?>
<Message xmlns:a="http://www.w3.org/2001/XMLSchema-instance" xmlns:b="https://www.gnu.org/licenses/gpl-3.0.en.html">
  <Type V="42" D="display" />
  <Version>v3.14 2024-03-13</Version>
  <MsgId>6591</MsgId>
</Message>
"""

print("XML-INPUT:\n", xml_data)

# Parse XML to dict, attribute fields are prefixed with "@"
dict_from_xml = xmltodict.parse(xml_data, process_namespaces=False)
print("TO DICT:")
pprint(dict_from_xml)
print("\nDICT BACK TO XML:")
print(xmltodict.unparse(dict_from_xml, pretty=True))


# Define pydantic models
class Base(BaseModel):
    V: int = Field(alias="@V")
    D: str = Field(alias="@D")


class Message(BaseModel):
    xmlns_a: str = Field(..., alias="@xmlns:a")
    xmlns_b: str = Field(..., alias="@xmlns:b")
    Version: str = Field("v3.14 2024-03-14")
    msg_id: int = Field(2398, alias="MsgId")
    Type: Base 

parsed = Message(**dict_from_xml["Message"])
print("\nPARSED PYDANTIC MODEL", parsed)


# Use polyfactor to generate new data
class MessageFactory(ModelFactory[Message]): ...


d_rand = {"Message": MessageFactory.build().dict()}

print("\nPLOYFACTORY DICT")
pprint(d_rand)

print("\nPLOYFACTORY DICT TO XML:")
print(xmltodict.unparse(d_rand, pretty=True))

Example output

Output from the code above is the following below. (Note how, as a result of not respecting the alias, the XML generated from the model polyfactory made is not the same structure as the initial.

XML input

We can read in some XML...

 <?xml version="1.0" encoding="iso-8859-1"?>
<Message xmlns:a="http://www.w3.org/2001/XMLSchema-instance" xmlns:b="https://www.gnu.org/licenses/gpl-3.0.en.html">
  <Type V="42" D="display" />
  <Version>v3.14 2024-03-13</Version>
  <MsgId>6591</MsgId>
</Message>

TO DICT

...convert it to dict, using xmltodict....

{'Message': {'@xmlns:a': 'http://www.w3.org/2001/XMLSchema-instance',
             '@xmlns:b': 'https://www.gnu.org/licenses/gpl-3.0.en.html',
             'MsgId': '6591',
             'Type': {'@D': 'display', '@V': '42'},
             'Version': 'v3.14 2024-03-13'}}

DICT BACK TO XML:

...and convert it back to the same XML

<?xml version="1.0" encoding="utf-8"?>
<Message xmlns:a="http://www.w3.org/2001/XMLSchema-instance" xmlns:b="https://www.gnu.org/licenses/gpl-3.0.en.html">
	<Type V="42" D="display"></Type>
	<Version>v3.14 2024-03-13</Version>
	<MsgId>6591</MsgId>
</Message>

PARSED PYDANTIC MODEL

The dictionary can be parsed by pydantic
xmlns_a='http://www.w3.org/2001/XMLSchema-instance' xmlns_b='https://www.gnu.org/licenses/gpl-3.0.en.html' Version='v3.14 2024-03-13' msg_id=6591 Type=Base(V=42, D='display')

PLOYFACTORY DICT

ployfactory can use the pydantic model to generate new values...

{'Message': {'Type': {'D': 'EPaZAPmJHmzqBySvSrVi', 'V': 4545},
             'Version': 'jAcoIAXetNLrCCyNWLTl',
             'msg_id': 8050,
             'xmlns_a': 'GKtRPetmEgYftxpIUBOD',
             'xmlns_b': 'sCrwQnTqWTFWEhMzxFwI'}}

PLOYFACTORY DICT TO XML:

...however, now xmlns:a fields are no longer attributes, nor the Type attirbues V and D, which instead become child elements.

<?xml version="1.0" encoding="utf-8"?>
<Message>
	<xmlns_a>GKtRPetmEgYftxpIUBOD</xmlns_a>
	<xmlns_b>sCrwQnTqWTFWEhMzxFwI</xmlns_b>
	<Version>jAcoIAXetNLrCCyNWLTl</Version>
	<msg_id>8050</msg_id>
	<Type>
		<V>4545</V>
		<D>EPaZAPmJHmzqBySvSrVi</D>
	</Type>
</Message>

[Alc-Alc]

Not sure I understood this, but isn't this just about doing d_rand = {"Message": MessageFactory.build().dict(by_alias=True)}?

[impaktor]

Thanks, that did the trick!
(I note there's no documentation for by_alias on polyfactory?)

[Alc-Alc]

@impaktor by_alias is part of the public api for BaseModel.dict (not sure about Pydantic v1, but it does in Pydantic v2)

IOW, you can not find that in polyfactory docs because it is not from polyfactory, it is from pydantic 🙂

[impaktor]

As an addendum, it was surprising / interesting to realize if I want to over-write one of the fields from default factory, the @classmethod must be named after the alias (in the code below pet_name must be refereed to by alias Name by the classmethod):

from polyfactory.factories.pydantic_factory import ModelFactory
from faker import Faker
from pydantic import BaseModel, Field
from uuid import UUID


class Pet(BaseModel):
    pet_name: str = Field("John Doe", alias="Name")


class Person(BaseModel):
    id: UUID
    name: str
    pets: Pet


class PetFactory(ModelFactory[Pet]):
    __set_as_default_factory_for_type__ = True
    __random_seed__ = 40
    __faker__ = Faker()

    # Note: "pet_name(cls)" will be ignored, use alias "Name(cls)":
    @classmethod
    def Name(cls) -> str:
        return cls.__faker__.name()


class PersonFactory(ModelFactory[Person]):
    ...


print("\nPERSON:")
print(PersonFactory.build())

print("\nPET:")
print(PetFactory.build())

[Alc-Alc]

@impaktor can you try this?

from pydantic import BaseModel, Field, ConfigDict

class Pet(BaseModel):
    model_config = ConfigDict(populate_by_name=True)
    pet_name: str = Field("John Doe", alias="Name")

    @classmethod
    def pet_name(cls) -> str:
        return cls.__faker__.name()

[impaktor]

Yeah, that works, thanks!

[guacs]

Hm...maybe we should default to always checking if any of the classmethods, Use fields etc. are defined based on the variable name rather than the alias? I can see a situation where the user doesn't want to populate by name, but also can't use the alias as the classmethod name since it may not be a valid identifier.