Meta: Llama 3 8B Instruct (free)

You can use the marshmallow library to generate dataclasses from the JSON. Here's an example of how you can do it:

import json
from marshmallow import Schema, fields, post_load

class OrderSchema(Schema):
    created = fields.DateTime(format='%Y-%m-%dT%H:%M:%S')
    amount = fields.Decimal(as_string=True)

    @post_load
    def to_order(self, data):
        return Order(**data)

class Order:
    def __init__(self, created, amount):
        self.created = created
        self.amount = amount

class PersonSchema(Schema):
    first_name = fields.Str()
    last_name = fields.Str()
    date_of_birth = fields.Date(format='%m/%d/%Y')
    orders = fields.Nested(OrderSchema, many=True)

    @post_load
    def to_person(self, data):
        return Person(**data)

class Person:
    def __init__(self, first_name, last_name, date_of_birth, orders):
        self.first_name = first_name
        self.last_name = last_name
        self.date_of_birth = date_of_birth
        self.orders = orders

person_schema = PersonSchema()
person_json = json.dumps({
  'first_name': 'Jane',
  'last_name': 'Smith',
  'date_of_birth': '03/16/1977',
  'orders': [
    {
      'created': '2024-01-25T15:00:04',
      'amount': '100.00'
    }
  ]
})

person = person_schema.loads(person_json)
print(person)  # Person(first_name='Jane', last_name='Smith', date_of_birth=datetime.date(1977, 3, 16), orders=[Order(created=datetime.datetime(2024, 1, 25, 15, 0, 4), amount=Decimal('100.00'))])

In this example, we define two schemas: OrderSchema and PersonSchema. OrderSchema has two fields: created which is a DateTime field and amount which is a Decimal field. The @post_load method is used to convert the deserialized data into an instance of the Order class.

PersonSchema has four fields: first_name and last_name which are Str fields, date_of_birth which is a Date field, and orders which is a list of Order instances (defined by the Nested field).

We then use the loads method of the PersonSchema to deserialize the JSON data into an instance of the Person class.

Note that you need to install the marshmallow library by running pip install marshmallow and also you need to have datetime and decimal libraries installed.

Here's how you can do it using the Marshmallow library in Python:

First, install the Marshmallow library if you haven't already:

pip install marshmallow

Then, create a dataclass for your JSON data:

from dataclasses import dataclass
from datetime import datetime
from marshmallow import Schema, fields

@dataclass
class Order:
    created: datetime
    amount: float

@dataclass
class Person:
    first_name: str
    last_name: str
    date_of_birth: datetime
    orders: list[Order]

class PersonSchema(Schema):
    first_name = fields.Str()
    last_name = fields.Str()
    date_of_birth = fields.Date(format='%m/%d/%Y')
    orders = fields.Nested('OrderSchema', many=True)

class OrderSchema(Schema):
    created = fields.DateTime(format='%Y-%m-%dT%H:%M:%S')
    amount = fields.Decimal(as_string=True)

person_schema = PersonSchema()
order_schema = OrderSchema()

person_data = {
    'first_name': 'Jane',
    'last_name': 'Smith',
    'date_of_birth': '03/16/1977',
    'orders': [
        {
            'created': '2024-01-25T15:00:04',
            'amount': '100.00'
        }
    ]
}

person = person_schema.load(person_data)
print(person)

In this code, we first define our dataclasses Person and Order. Then, we define our schema classes PersonSchema and OrderSchema using Marshmallow's Schema and fields classes. We specify the data types for each field in the schema. Finally, we create instances of our schema classes and use them to load our JSON data into our dataclasses.

You can use the marshmallow library to generate dataclasses from your JSON. Here's an example of how you can do it:

import datetime
from marshmallow import Schema, fields, post_load

class OrderSchema(Schema):
    created = fields.DateTime(format='%Y-%m-%dT%H:%M:%S')
    amount = fields.Decimal(as_string=True)

    @post_load
    def make_order(self, data):
        return Order(**data)

class Order:
    def __init__(self, created, amount):
        self.created = created
        self.amount = amount

class PersonSchema(Schema):
    first_name = fields.Str()
    last_name = fields.Str()
    date_of_birth = fields.Date(format='%m/%d/%Y')
    orders = fields.Nested(OrderSchema, many=True)

    @post_load
    def make_person(self, data):
        return Person(**data)

class Person:
    def __init__(self, first_name, last_name, date_of_birth, orders):
        self.first_name = first_name
        self.last_name = last_name
        self.date_of_birth = date_of_birth
        self.orders = orders

# Load the JSON data
json_data = '''
{
  "first_name": "Jane",
  "last_name": "Smith",
  "date_of_birth": "03/16/1977",
  "orders": [
    {
      "created": "2024-01-25T15:00:04",
      "amount": "100.00"
    }
  ]
}
'''

person_schema = PersonSchema()
person = person_schema.load(json.loads(json_data))

print(person.first_name)  # Jane
print(person.last_name)  # Smith
print(person.date_of_birth)  # datetime.date(1977, 3, 16)
print(person.orders[0].created)  # datetime.datetime(2024, 1, 25, 15, 0, 4)
print(person.orders[0].amount)  # Decimal('100.00')

Here's what's happening:

1. We define two dataclasses, Order and Person, to represent the data in our JSON.
2. We define two schemas, OrderSchema and PersonSchema, using the marshmallow library. These schemas define the structure of our dataclasses.
3. We use the @post_load decorator to define a function that will be called after the data is loaded. This function is used to create an instance of our dataclass from the loaded data.
4. We load the JSON data using the load method of our PersonSchema.
5. We print out the attributes of our Person object to verify that the data was loaded correctly.

Note that we use the fields.DateTime and fields.Date classes to specify the format of the created and date_of_birth fields, respectively. We also use the fields.Decimal class to specify that the amount field should be a decimal value.