rxfoundry.clients.swifty-oauth-api 0.0.620__py3-none-any.whl → 1.0.0__py3-none-any.whl

rxfoundry/clients/p2rx_api/models/error_message.py

@@ -1,90 +0,0 @@
-# coding: utf-8
-
-"""
-    P2RX API
-
-    API for the P2RX Backend 
-
-    The version of the OpenAPI document: 0.1.DEV-0
-    Contact: paul.tindall@rxfoundry.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
-from typing import Optional, Set
-from typing_extensions import Self
-
-class ErrorMessage(BaseModel):
-    """
-    ErrorMessage
-    """ # noqa: E501
-    error_code: Optional[StrictStr] = None
-    error_message: Optional[StrictStr] = None
-    __properties: ClassVar[List[str]] = ["error_code", "error_message"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of ErrorMessage from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of ErrorMessage from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "error_code": obj.get("error_code"),
-            "error_message": obj.get("error_message")
-        })
-        return _obj
-
-

rxfoundry/clients/p2rx_api/models/fax.py

@@ -1,141 +0,0 @@
-# coding: utf-8
-
-"""
-    P2RX API
-
-    API for the P2RX Backend 
-
-    The version of the OpenAPI document: 0.1.DEV-0
-    Contact: paul.tindall@rxfoundry.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from datetime import datetime
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictFloat, StrictInt, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional, Union
-from rxfoundry.clients.swifty_api.models.medication import Medication
-from rxfoundry.clients.swifty_api.models.patient import Patient
-from rxfoundry.clients.swifty_api.models.prescriber import Prescriber
-from rxfoundry.clients.swifty_api.models.virtual_pharmacy import VirtualPharmacy
-from typing import Optional, Set
-from typing_extensions import Self
-
-class Fax(BaseModel):
-    """
-    Fax
-    """ # noqa: E501
-    uuid: Optional[StrictStr] = None
-    fax_id: Optional[StrictStr] = None
-    fax_date: Optional[datetime] = None
-    to_fax_number: Optional[StrictStr] = None
-    from_fax_number: Optional[StrictStr] = None
-    filename: Optional[StrictStr] = None
-    fax_image: Optional[StrictStr] = None
-    fax_page_count: Optional[StrictInt] = None
-    virtual_pharmacy: Optional[VirtualPharmacy] = None
-    patient: Optional[Patient] = None
-    prescriber: Optional[Prescriber] = None
-    medication: Optional[Medication] = None
-    ndc: Optional[StrictStr] = None
-    days_supply: Optional[StrictInt] = None
-    quantity_value: Optional[Union[StrictFloat, StrictInt]] = None
-    number_of_fills: Optional[StrictInt] = None
-    sig_text: Optional[StrictStr] = None
-    is_completed: Optional[StrictBool] = None
-    has_running_workflow: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["uuid", "fax_id", "fax_date", "to_fax_number", "from_fax_number", "filename", "fax_image", "fax_page_count", "virtual_pharmacy", "patient", "prescriber", "medication", "ndc", "days_supply", "quantity_value", "number_of_fills", "sig_text", "is_completed", "has_running_workflow"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Fax from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of virtual_pharmacy
-        if self.virtual_pharmacy:
-            _dict['virtual_pharmacy'] = self.virtual_pharmacy.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of patient
-        if self.patient:
-            _dict['patient'] = self.patient.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of prescriber
-        if self.prescriber:
-            _dict['prescriber'] = self.prescriber.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of medication
-        if self.medication:
-            _dict['medication'] = self.medication.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Fax from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "uuid": obj.get("uuid"),
-            "fax_id": obj.get("fax_id"),
-            "fax_date": obj.get("fax_date"),
-            "to_fax_number": obj.get("to_fax_number"),
-            "from_fax_number": obj.get("from_fax_number"),
-            "filename": obj.get("filename"),
-            "fax_image": obj.get("fax_image"),
-            "fax_page_count": obj.get("fax_page_count"),
-            "virtual_pharmacy": VirtualPharmacy.from_dict(obj["virtual_pharmacy"]) if obj.get("virtual_pharmacy") is not None else None,
-            "patient": Patient.from_dict(obj["patient"]) if obj.get("patient") is not None else None,
-            "prescriber": Prescriber.from_dict(obj["prescriber"]) if obj.get("prescriber") is not None else None,
-            "medication": Medication.from_dict(obj["medication"]) if obj.get("medication") is not None else None,
-            "ndc": obj.get("ndc"),
-            "days_supply": obj.get("days_supply"),
-            "quantity_value": obj.get("quantity_value"),
-            "number_of_fills": obj.get("number_of_fills"),
-            "sig_text": obj.get("sig_text"),
-            "is_completed": obj.get("is_completed"),
-            "has_running_workflow": obj.get("has_running_workflow")
-        })
-        return _obj
-
-

rxfoundry/clients/p2rx_api/models/medication.py

@@ -1,137 +0,0 @@
-# coding: utf-8
-
-"""
-    P2RX API
-
-    API for the P2RX Backend 
-
-    The version of the OpenAPI document: 0.1.DEV-0
-    Contact: paul.tindall@rxfoundry.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
-from rxfoundry.clients.swifty_api.models.code_qualifier_code import CodeQualifierCode
-from rxfoundry.clients.swifty_api.models.medication_program_pricing import MedicationProgramPricing
-from rxfoundry.clients.swifty_api.models.medication_variant import MedicationVariant
-from typing import Optional, Set
-from typing_extensions import Self
-
-class Medication(BaseModel):
-    """
-    Medication
-    """ # noqa: E501
-    uuid: Optional[StrictStr] = None
-    drug_description: Optional[StrictStr] = None
-    drug_strength: Optional[StrictStr] = None
-    drug_strength_form: Optional[StrictStr] = None
-    drug_strength_uom: Optional[StrictStr] = None
-    is_brand: Optional[StrictBool] = None
-    program_pricing: Optional[List[MedicationProgramPricing]] = None
-    variants: Optional[List[MedicationVariant]] = None
-    medication_product_codes: Optional[List[CodeQualifierCode]] = None
-    medication_drug_database_codes: Optional[List[CodeQualifierCode]] = None
-    __properties: ClassVar[List[str]] = ["uuid", "drug_description", "drug_strength", "drug_strength_form", "drug_strength_uom", "is_brand", "program_pricing", "variants", "medication_product_codes", "medication_drug_database_codes"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Medication from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of each item in program_pricing (list)
-        _items = []
-        if self.program_pricing:
-            for _item_program_pricing in self.program_pricing:
-                if _item_program_pricing:
-                    _items.append(_item_program_pricing.to_dict())
-            _dict['program_pricing'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in variants (list)
-        _items = []
-        if self.variants:
-            for _item_variants in self.variants:
-                if _item_variants:
-                    _items.append(_item_variants.to_dict())
-            _dict['variants'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in medication_product_codes (list)
-        _items = []
-        if self.medication_product_codes:
-            for _item_medication_product_codes in self.medication_product_codes:
-                if _item_medication_product_codes:
-                    _items.append(_item_medication_product_codes.to_dict())
-            _dict['medication_product_codes'] = _items
-        # override the default output from pydantic by calling `to_dict()` of each item in medication_drug_database_codes (list)
-        _items = []
-        if self.medication_drug_database_codes:
-            for _item_medication_drug_database_codes in self.medication_drug_database_codes:
-                if _item_medication_drug_database_codes:
-                    _items.append(_item_medication_drug_database_codes.to_dict())
-            _dict['medication_drug_database_codes'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Medication from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "uuid": obj.get("uuid"),
-            "drug_description": obj.get("drug_description"),
-            "drug_strength": obj.get("drug_strength"),
-            "drug_strength_form": obj.get("drug_strength_form"),
-            "drug_strength_uom": obj.get("drug_strength_uom"),
-            "is_brand": obj.get("is_brand"),
-            "program_pricing": [MedicationProgramPricing.from_dict(_item) for _item in obj["program_pricing"]] if obj.get("program_pricing") is not None else None,
-            "variants": [MedicationVariant.from_dict(_item) for _item in obj["variants"]] if obj.get("variants") is not None else None,
-            "medication_product_codes": [CodeQualifierCode.from_dict(_item) for _item in obj["medication_product_codes"]] if obj.get("medication_product_codes") is not None else None,
-            "medication_drug_database_codes": [CodeQualifierCode.from_dict(_item) for _item in obj["medication_drug_database_codes"]] if obj.get("medication_drug_database_codes") is not None else None
-        })
-        return _obj
-
-

rxfoundry/clients/p2rx_api/models/medication_program_pricing.py

@@ -1,99 +0,0 @@
-# coding: utf-8
-
-"""
-    P2RX API
-
-    API for the P2RX Backend 
-
-    The version of the OpenAPI document: 0.1.DEV-0
-    Contact: paul.tindall@rxfoundry.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from datetime import date
-from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt
-from typing import Any, ClassVar, Dict, List, Optional, Union
-from rxfoundry.clients.swifty_api.models.pricing_program import PricingProgram
-from typing import Optional, Set
-from typing_extensions import Self
-
-class MedicationProgramPricing(BaseModel):
-    """
-    MedicationProgramPricing
-    """ # noqa: E501
-    pricing_program: Optional[PricingProgram] = None
-    from_date: Optional[date] = None
-    to_date: Optional[date] = None
-    ingredient_cost: Optional[Union[StrictFloat, StrictInt]] = None
-    __properties: ClassVar[List[str]] = ["pricing_program", "from_date", "to_date", "ingredient_cost"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of MedicationProgramPricing from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of pricing_program
-        if self.pricing_program:
-            _dict['pricing_program'] = self.pricing_program.to_dict()
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of MedicationProgramPricing from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "pricing_program": PricingProgram.from_dict(obj["pricing_program"]) if obj.get("pricing_program") is not None else None,
-            "from_date": obj.get("from_date"),
-            "to_date": obj.get("to_date"),
-            "ingredient_cost": obj.get("ingredient_cost")
-        })
-        return _obj
-
-

rxfoundry/clients/p2rx_api/models/medication_variant.py

@@ -1,96 +0,0 @@
-# coding: utf-8
-
-"""
-    P2RX API
-
-    API for the P2RX Backend 
-
-    The version of the OpenAPI document: 0.1.DEV-0
-    Contact: paul.tindall@rxfoundry.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, StrictBool, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
-from typing import Optional, Set
-from typing_extensions import Self
-
-class MedicationVariant(BaseModel):
-    """
-    MedicationVariant
-    """ # noqa: E501
-    uuid: Optional[StrictStr] = None
-    ndc: Optional[StrictStr] = None
-    manufacturer: Optional[StrictStr] = None
-    packaging: Optional[StrictStr] = None
-    is_brand: Optional[StrictBool] = None
-    __properties: ClassVar[List[str]] = ["uuid", "ndc", "manufacturer", "packaging", "is_brand"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of MedicationVariant from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of MedicationVariant from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "uuid": obj.get("uuid"),
-            "ndc": obj.get("ndc"),
-            "manufacturer": obj.get("manufacturer"),
-            "packaging": obj.get("packaging"),
-            "is_brand": obj.get("is_brand")
-        })
-        return _obj
-
-

rxfoundry/clients/p2rx_api/models/patient.py

@@ -1,128 +0,0 @@
-# coding: utf-8
-
-"""
-    P2RX API
-
-    API for the P2RX Backend 
-
-    The version of the OpenAPI document: 0.1.DEV-0
-    Contact: paul.tindall@rxfoundry.com
-    Generated by OpenAPI Generator (https://openapi-generator.tech)
-
-    Do not edit the class manually.
-"""  # noqa: E501
-
-
-from __future__ import annotations
-import pprint
-import re  # noqa: F401
-import json
-
-from pydantic import BaseModel, ConfigDict, StrictStr
-from typing import Any, ClassVar, Dict, List, Optional
-from rxfoundry.clients.swifty_api.models.address import Address
-from rxfoundry.clients.swifty_api.models.code import Code
-from rxfoundry.clients.swifty_api.models.patient_external_identifier import PatientExternalIdentifier
-from typing import Optional, Set
-from typing_extensions import Self
-
-class Patient(BaseModel):
-    """
-    Patient
-    """ # noqa: E501
-    uuid: Optional[StrictStr] = None
-    last_name: Optional[StrictStr] = None
-    first_name: Optional[StrictStr] = None
-    middle_name: Optional[StrictStr] = None
-    suffix: Optional[StrictStr] = None
-    prefix: Optional[StrictStr] = None
-    gender: Optional[Code] = None
-    date_of_birth: Optional[StrictStr] = None
-    home_address: Optional[Address] = None
-    primary_phone: Optional[StrictStr] = None
-    alternate_phone: Optional[StrictStr] = None
-    email: Optional[StrictStr] = None
-    external_references: Optional[List[PatientExternalIdentifier]] = None
-    __properties: ClassVar[List[str]] = ["uuid", "last_name", "first_name", "middle_name", "suffix", "prefix", "gender", "date_of_birth", "home_address", "primary_phone", "alternate_phone", "email", "external_references"]
-
-    model_config = ConfigDict(
-        populate_by_name=True,
-        validate_assignment=True,
-        protected_namespaces=(),
-    )
-
-
-    def to_str(self) -> str:
-        """Returns the string representation of the model using alias"""
-        return pprint.pformat(self.model_dump(by_alias=True))
-
-    def to_json(self) -> str:
-        """Returns the JSON representation of the model using alias"""
-        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
-        return json.dumps(self.to_dict())
-
-    @classmethod
-    def from_json(cls, json_str: str) -> Optional[Self]:
-        """Create an instance of Patient from a JSON string"""
-        return cls.from_dict(json.loads(json_str))
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Return the dictionary representation of the model using alias.
-
-        This has the following differences from calling pydantic's
-        `self.model_dump(by_alias=True)`:
-
-        * `None` is only added to the output dict for nullable fields that
-          were set at model initialization. Other fields with value `None`
-          are ignored.
-        """
-        excluded_fields: Set[str] = set([
-        ])
-
-        _dict = self.model_dump(
-            by_alias=True,
-            exclude=excluded_fields,
-            exclude_none=True,
-        )
-        # override the default output from pydantic by calling `to_dict()` of gender
-        if self.gender:
-            _dict['gender'] = self.gender.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of home_address
-        if self.home_address:
-            _dict['home_address'] = self.home_address.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of each item in external_references (list)
-        _items = []
-        if self.external_references:
-            for _item_external_references in self.external_references:
-                if _item_external_references:
-                    _items.append(_item_external_references.to_dict())
-            _dict['external_references'] = _items
-        return _dict
-
-    @classmethod
-    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
-        """Create an instance of Patient from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return cls.model_validate(obj)
-
-        _obj = cls.model_validate({
-            "uuid": obj.get("uuid"),
-            "last_name": obj.get("last_name"),
-            "first_name": obj.get("first_name"),
-            "middle_name": obj.get("middle_name"),
-            "suffix": obj.get("suffix"),
-            "prefix": obj.get("prefix"),
-            "gender": Code.from_dict(obj["gender"]) if obj.get("gender") is not None else None,
-            "date_of_birth": obj.get("date_of_birth"),
-            "home_address": Address.from_dict(obj["home_address"]) if obj.get("home_address") is not None else None,
-            "primary_phone": obj.get("primary_phone"),
-            "alternate_phone": obj.get("alternate_phone"),
-            "email": obj.get("email"),
-            "external_references": [PatientExternalIdentifier.from_dict(_item) for _item in obj["external_references"]] if obj.get("external_references") is not None else None
-        })
-        return _obj
-
-