`oneOf` inside `allOf` is ignored during code generation

openapi: 3.0.3
info:
  title: AllOf + OneOf Test
  version: 1.0.0
paths:
  /animals/{animal_id}:
    get:
      operationId: get_animal
      parameters:
        - name: animal_id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Animal'

components:
  schemas:
    Animal:
      type: object
      required:
        - id
        - attributes
      properties:
        id:
          type: string
        attributes:
          allOf:
            - $ref: '#/components/schemas/CommonAttributes'
            - oneOf:
                - $ref: '#/components/schemas/DogAttributes'
                - $ref: '#/components/schemas/CatAttributes'

    CommonAttributes:
      type: object
      properties:
        name:
          type: string
          description: Animal's name
        age:
          type: integer
          description: Animal's age in years

    DogAttributes:
      type: object
      properties:
        breed:
          type: string
          description: Dog breed
        is_good_boy:
          type: boolean
          description: Is this a good boy?

    CatAttributes:
      type: object
      properties:
        color:
          type: string
          description: Cat fur color
        lives_remaining:
          type: integer
          description: Number of lives remaining (out of 9)

from typing import Any, TypeVar, Union

from attrs import define as _attrs_define
from attrs import field as _attrs_field

from ..types import UNSET, Unset

T = TypeVar("T", bound="AnimalAttributes")


@_attrs_define
class AnimalAttributes:
    """
    Attributes:
        name (Union[Unset, str]): Animal's name
        age (Union[Unset, int]): Animal's age in years
    """

    name: Union[Unset, str] = UNSET
    age: Union[Unset, int] = UNSET
    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)

    def to_dict(self) -> dict[str, Any]:
        name = self.name

        age = self.age

        field_dict: dict[str, Any] = {}
        field_dict.update(self.additional_properties)
        field_dict.update({})
        if name is not UNSET:
            field_dict["name"] = name
        if age is not UNSET:
            field_dict["age"] = age

        return field_dict

    @classmethod
    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
        d = src_dict.copy()
        name = d.pop("name", UNSET)

        age = d.pop("age", UNSET)

        animal_attributes = cls(
            name=name,
            age=age,
        )

        animal_attributes.additional_properties = d
        return animal_attributes

    @property
    def additional_keys(self) -> list[str]:
        return list(self.additional_properties.keys())

    def __getitem__(self, key: str) -> Any:
        return self.additional_properties[key]

    def __setitem__(self, key: str, value: Any) -> None:
        self.additional_properties[key] = value

    def __delitem__(self, key: str) -> None:
        del self.additional_properties[key]

    def __contains__(self, key: str) -> bool:
        return key in self.additional_properties