Having trouble parsing attrs model

[Leem0sh]

Hello, having a bit of trouble with parsing attr Model. I'm mostly using pydantic models and now I'm a little confused with attrs Models.

Having models like

from ninja import Schema

class Range(Schema):
    rangeFrom: Optional[PositiveInt]
    rangeTo: Optional[PositiveInt]


class DimensionsMeasurementSchema(Schema):
    unit: str
    trustful: bool
    model: str
    x: Range
    y: Range
    z: Range
    d: Range


class RawData(Schema):
    raw_coroner_response: Any
    raw_parser_response: Any


class DimensionsVariantSchema(Schema):
    project_id: PositiveInt
    variant_id: PositiveInt
    name: str
    description: str
    content_checksum: ContentChecksum

which are after client generation converted into:

@attr.s(auto_attribs=True)
class CreateMeasurementBodyParams:
    """
    Attributes:
        variant (DimensionsVariantSchema):
        measurement (DimensionsMeasurementSchema):
        raw (RawData):
    """

    variant: DimensionsVariantSchema
    measurement: DimensionsMeasurementSchema
    raw: RawData
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)


@attr.s(auto_attribs=True)
class DimensionsVariantSchema:
    """
    Attributes:
        project_id (int):
        variant_id (int):
        name (str):
        description (str):
        content_checksum (str):
    """

    project_id: int
    variant_id: int
    name: str
    description: str
    content_checksum: str
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)


@attr.s(auto_attribs=True)
class DimensionsMeasurementSchema:
    """
    Attributes:
        unit (str):
        trustful (bool):
        model (str):
        x (Range):
        y (Range):
        z (Range):
        d (Range):
    """

    unit: str
    trustful: bool
    model: str
    x: Range
    y: Range
    z: Range
    d: Range
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

class RawData:
    """
    Attributes:
        raw_coroner_response (Union[Unset, Any]):
        raw_parser_response (Union[Unset, Any]):
    """

    raw_coroner_response: Union[Unset, Any] = UNSET
    raw_parser_response: Union[Unset, Any] = UNSET
    additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)

My main goal is to generate appilcation client with models that can be used in another applications for obvious reasons. For example when I'm about to use generated function create_measurement.sync(client=CLIENT, json_body=data). But as I understood json_body needs to have the CreateMeasurementBodyParams Model. Which is fine and I understand. But what is the proper way of parsing a dictionary into this Model when additional_properties are added into every Model and SubModel?

I have an example:

final_d = {'measurement': {'d': {'rangeFrom': None, 'rangeTo': None},
                 'model': 'model1',
                 'trustful': True,
                 'unit': 'mm',
                 'x': {'rangeFrom': None, 'rangeTo': None},
                 'y': {'rangeFrom': 1000.0, 'rangeTo': None},
                 'z': {'rangeFrom': None, 'rangeTo': None}},
 'raw': {'raw_coroner_response': {'unit': [{'trustful': True, 'value': 'cm'}],
                                  'x': [],
                                  'y': [{'trustful': True, 'value': '100'}],
                                  'z': []},
         'raw_parsed_response': {'d': {'rangeFrom': None, 'rangeTo': None},
                                 'model': 'model1',
                                 'trustful': True,
                                 'unit': 'mm',
                                 'x': {'rangeFrom': None, 'rangeTo': None},
                                 'y': {'rangeFrom': 1000.0, 'rangeTo': None},
                                 'z': {'rangeFrom': None, 'rangeTo': None}}},
 'variant': {'content_checksum': 'abcdefghi123456789321',
             'description': 'very long long long description',
             'name': 'some_name',
             'project_id': 1,
             'variant_id': 123456}}


base_url = "some_base_url"
token = "secrettoken"

modeled_data = CreateMeasurementBodyParams.from_dict(final_d)
# or maybe CreateMeasurementBodyParams(**final_d) ?

pprint(modeled_data)

client = AuthenticatedClient(base_url=base_url, token=token)
create_measurement.sync(client=client, json_body=modeled_data) # 

Here I'm just creating a dictionary which is suitable for the CreateMeasurementBodyParams (or at least for pydantic model it would be). But then I'm not able to parse it bcs of the additional_proparties that are added to the model when generated and I'm not able to use create_measure.sync GENERATED function bcs I'm not able to pass data into it. What am I doing wrong?

[dbanty]

I'm confused about what exactly it is you're trying to do that you're unable to. It sounds like you're able to get a CreateMeasurementBodyParams successfully using the generated from_dict method. This is expected as the class should be buildable via any valid JSON for the model.

You then say you aren't able to parse it because of additional_properties and you cannot use the generated function because you are not able to pass data into it. My questions are:

1. What do you mean by "I'm not able to parse it bcs of the additional_properties"? If you use the to_dict method on the generated class, you should get out the same dictionary that you put in to from_dict.
2. What happens when you try to call create_measurement.sync? Are you getting some sort of exception?