Contents

Modules Documentation

Main FastAPI app instance declaration

async app.main.console_log_requests(request: Request, call_next)

async app.main.log_requests(request: Request, call_next)

async app.main.pong()

async app.main.root()

async app.main.shutdown_event()

async app.main.startup_event()

class app.models.Application(**kwargs)

Bases: Base

Model for job applications. Contains cover letter, resume, notes, status. Linked to users and job leads through many-to-one relationships.

cover_letters

created_at

id

lead

lead_id

resumes

status

updated_at

user

user_id

class app.models.Base(**kwargs: Any)

Bases: DeclarativeBase

Base model for all database entities. Provides common attributes like ID, creation, and update timestamps. Inherits from SQLAlchemy’s DeclarativeBase.

created_at = Column(None, DateTime(), table=None, default=ColumnElementColumnDefault(<sqlalchemy.sql.functions.now at 0x1054c4b90; now>))

id = Column(None, UUID(), table=None, primary_key=True, nullable=False, default=CallableColumnDefault(<function uuid4>))

metadata: ClassVar[MetaData] = MetaData()

Refers to the _schema.MetaData collection that will be used for new _schema.Table objects.

See also

orm_declarative_metadata

registry: ClassVar[_RegistryType] = <sqlalchemy.orm.decl_api.registry object>

Refers to the _orm.registry in use where new _orm.Mapper objects will be associated.

updated_at = Column(None, DateTime(), table=None, onupdate=ColumnElementColumnDefault(<sqlalchemy.sql.functions.now at 0x105502410; now>), default=ColumnElementColumnDefault(<sqlalchemy.sql.functions.now at 0x1054c50d0; now>))

class app.models.Certificate(**kwargs)

Bases: Base

created_at

expiration_date

id

issued_date

issuer

title

updated_at

user

user_id

class app.models.Contact(**kwargs)

Bases: Base

Represents a contact associated with a user. Stores details like name, phone, email, notes.

created_at

email

first_name

id

last_name

notes

phone_number

time_zone

updated_at

user

user_id

class app.models.CoverLetter(**kwargs)

Bases: Base

Represents a user’s cover letter. Includes name, content, type. Linked to users and job applications via many-to-one and many-to-many relationships.

applications

content

content_type

created_at

id

name

updated_at

user

user_id

class app.models.CoverLetterXApplication(**kwargs)

Bases: Base

Crosswalk table for cover letters and job applications many-to-many relationship.

application_id

cover_letter_id

created_at

id

updated_at

class app.models.Education(**kwargs)

Bases: Base

achievements

activities

created_at

degree

end_date

gradePoint

id

start_date

university

updated_at

user

user_id

class app.models.Experience(**kwargs)

Bases: Base

Represents user’s professional experience. Links to user with job title, company, duration details.

company

created_at

description

end_date

id

location

projects

start_date

title

updated_at

user

user_id

class app.models.Extractor(**kwargs)

Bases: Base

Represents an extractor for parsing structured data from unstructured text. Contains name, description, schema, instruction, etc. Linked to users and examples via many-to-one and one-to-many relationships.

created_at

description

extractor_examples

id

instruction

json_schema

name

updated_at

user

user_id

class app.models.ExtractorExample(**kwargs)

Bases: Base

A representation of an example.

Examples consist of content together with the expected output.

The output is a JSON object that is expected to be extracted from the content.

The JSON object should be valid according to the schema of the associated extractor.

The JSON object is defined by the schema of the associated extractor, so it’s perfectly fine for a given example to represent the extraction of multiple instances of some object from the content since the JSON schema can represent a list of objects.

content

created_at

extractor

extractor_id

id

output

updated_at

class app.models.Lead(**kwargs)

Bases: Base

Represents a job lead. Includes URL, title, company, description, location, salary, etc. Linked to job applications via one-to-many relationship.

application

company

created_at

description

education_level

employment_type

hiring_manager

id

industries

job_function

location

notes

salary

seniority_level

title

updated_at

url

class app.models.OrchestrationEvent(**kwargs)

Bases: Base

Model for orchestration events. Contains job name, status, message, and reference to the pipeline. Useful for tracking the status of ETL jobs.

created_at

destination_uri

id

message

name

orchestration_pipeline

pipeline_id

source_uri

status

updated_at

class app.models.OrchestrationPipeline(**kwargs)

Bases: Base

Model for ETL (Extract, Transform, Load) pipelines. Contains name, description, source, destination, and parameters. Linked to orchestration events via one-to-many relationship.

created_at

description

id

name

orchestration_events

params

updated_at

user

user_id

class app.models.Resume(**kwargs)

Bases: Base

Represents a user’s resume. Contains name, content, type. Linked to users and job applications via many-to-one and many-to-many relationships.

applications

content

content_type

created_at

id

name

updated_at

user

user_id

class app.models.ResumeXApplication(**kwargs)

Bases: Base

Crosswalk table for resumes and job applications many-to-many relationship.

application_id

created_at

id

resume_id

updated_at

class app.models.Skill(**kwargs)

Bases: Base

Model for user skills. Each skill associated with a user via many-to-one relationship.

category

created_at

id

name

subskills

updated_at

user

user_id

yoe

class app.models.User(**kwargs)

Bases: SQLAlchemyBaseUserTableUUID, Base

Extended user model with additional fields like name, contact information, and address. Core of user-related operations, linked to applications, skills, experiences, etc.

address_line_1

address_line_2

applications

avatar_uri

certificates

city

contacts

country

cover_letters

created_at

education

email: Mapped[str]

experiences

extractors

first_name

hashed_password: Mapped[str]

id: Mapped[UUID_ID]

is_active: Mapped[bool]

is_superuser: Mapped[bool]

is_verified: Mapped[bool]

last_name

orchestration_pipelines

phone_number

resumes

skills

state

time_zone

updated_at

zip_code

class app.schemas.ApplicationCreate(*, lead_id: UUID, status: str)

Bases: BaseSchema

lead_id: UUID

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'lead_id': FieldInfo(annotation=UUID, required=True, metadata=[UuidVersion(uuid_version=4)]), 'status': FieldInfo(annotation=str, required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

status: str

class app.schemas.ApplicationRead(*, id: UUID, created_at: datetime, updated_at: datetime, lead_id: UUID, user_id: UUID, lead: LeadRead, user: UserRead, status: str | None = None)

Bases: BaseRead

lead: LeadRead

lead_id: UUID

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'lead': FieldInfo(annotation=LeadRead, required=True), 'lead_id': FieldInfo(annotation=UUID, required=True, metadata=[UuidVersion(uuid_version=4)]), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Application status'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated'), 'user': FieldInfo(annotation=UserRead, required=True), 'user_id': FieldInfo(annotation=UUID, required=True, metadata=[UuidVersion(uuid_version=4)])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

status: str | None

user: UserRead

user_id: UUID

class app.schemas.ApplicationUpdate(*, status: str)

Bases: BaseSchema

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'status': FieldInfo(annotation=str, required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

status: str

class app.schemas.BaseCertificate(*, title: str | None = None, issuer: str | None = None, expiration_date: datetime | None = None, issued_date: datetime | None = None)

Bases: BaseSchema

expiration_date: datetime | None

issued_date: datetime | None

issuer: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'expiration_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Expiration date of the certificate'), 'issued_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Issued date of the certificate'), 'issuer': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Issuer of the certificate'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Certificate title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

title: str | None

class app.schemas.BaseContact(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, email: EmailStr | None = None, time_zone: str | None = None, notes: str | None = None)

Bases: BaseSchema

email: EmailStr | None

first_name: str | None

last_name: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'email': FieldInfo(annotation=Union[EmailStr, NoneType], required=False, default=None, description='Email address'), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

notes: str | None

phone_number: str | None

time_zone: str | None

class app.schemas.BaseCoverLetter(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None)

Bases: BaseSchema

content: str | None

content_type: ContentType | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Cover letter content type'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str | None

class app.schemas.BaseEducation(*, university: str | None = None, degree: str | None = None, gradePoint: str | None = None, activities: str | None = None, achievements: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None)

Bases: BaseSchema

achievements: str | None

activities: str | None

degree: str | None

end_date: datetime | None

gradePoint: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'achievements': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Achievements'), 'activities': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Activities involved'), 'degree': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Degree name'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the education'), 'gradePoint': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Grade point'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the education'), 'university': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='University name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

start_date: datetime | None

university: str | None

class app.schemas.BaseExperience(*, title: str | None = None, company: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None, description: str | None = None, location: str | None = None, projects: str | None = None)

Bases: BaseSchema

company: str | None

description: str | None

end_date: datetime | None

location: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the experience'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the experience'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Location of the experience'), 'projects': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Projects involved'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the experience'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

projects: str | None

start_date: datetime | None

title: str | None

class app.schemas.BaseExtractor(*, name: str | None = None, description: str | None = None, json_schema: dict | str | None = None, instruction: str | None = None, extractor_examples: list[ExtractorExampleRead] = [])

Bases: BaseSchema

description: str | None

extractor_examples: list[ExtractorExampleRead]

instruction: str | None

json_schema: dict | str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor description'), 'extractor_examples': FieldInfo(annotation=list[ExtractorExampleRead], required=False, default=[], description='Extractor examples'), 'instruction': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor instruction'), 'json_schema': FieldInfo(annotation=Union[dict, str, NoneType], required=False, default=None, description='JSON schema'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str | None

classmethod validate_schema(v: Any) → dict[str, Any]

Validate the schema.

class app.schemas.BaseExtractorExample(*, content: str | None = None, output: str | None = None)

Bases: BaseSchema

content: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example content'), 'output': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example output')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

output: str | None

class app.schemas.BaseLead(*, title: str | None = None, company: str | None = None, description: str | None = None, location: str | None = None, salary: str | None = None, job_function: str | None = None, industries: str | None = None, employment_type: str | None = None, seniority_level: str | None = None, education_level: str | None = None, notes: str | None = None, hiring_manager: str | None = None)

Bases: BaseSchema

company: str | None

description: str | None

education_level: str | None

employment_type: str | None

hiring_manager: str | None

industries: str | None

job_function: str | None

location: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job description'), 'education_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Required education level'), 'employment_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Type of employment'), 'hiring_manager': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Hiring manager'), 'industries': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Industries involved'), 'job_function': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job function'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job location'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'salary': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Salary range'), 'seniority_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Seniority level'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

notes: str | None

salary: str | None

seniority_level: str | None

title: str | None

class app.schemas.BaseOrchestrationEvent(*, name: str | None = None, message: str | None = None, source_uri: URI | None = None, destination_uri: URI | None = None, status: OrchestrationEventStatusType | None = None, pipeline_id: UUID | None = None)

Bases: BaseSchema

destination_uri: URI | None

message: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'destination_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Destination of the pipeline'), 'message': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Error message'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the event'), 'pipeline_id': FieldInfo(annotation=Union[Annotated[UUID, UuidVersion], NoneType], required=False, default=None, description='Pipeline ID'), 'source_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Source of the pipeline'), 'status': FieldInfo(annotation=Union[OrchestrationEventStatusType, NoneType], required=False, default=None, description='Status of the event')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str | None

pipeline_id: UUID | None

source_uri: URI | None

status: OrchestrationEventStatusType | None

classmethod validate_uri(v: Any) → URI | None

class app.schemas.BaseOrchestrationPipeline(*, name: str | None = None, description: str | None = None, params: dict | None = None)

Bases: BaseSchema

description: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the pipeline'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the pipeline'), 'params': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None, description='Parameters for the pipeline')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str | None

params: dict | None

class app.schemas.BaseRead(*, id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseSchema

created_at: datetime

id: UUID

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

updated_at: datetime

class app.schemas.BaseResume(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None)

Bases: BaseSchema

content: str | None

content_type: ContentType | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Resume content type'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str | None

class app.schemas.BaseSchema

Bases: BaseModel

class Config

Bases: object

from_attributes = True

protected_namespaces = ()

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.BaseSkill(*, name: str | None = None, category: str | None = None, yoe: int | None = None, subskills: str | None = None)

Bases: BaseSchema

category: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Category of the skill'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the skill'), 'subskills': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Sub-Skills'), 'yoe': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, description='Years of Experience')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str | None

subskills: str | None

yoe: int | None

class app.schemas.BaseUser(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, address_line_1: str | None = None, address_line_2: str | None = None, city: str | None = None, state: str | None = None, zip_code: str | None = None, country: str | None = None, time_zone: str | None = None, avatar_uri: URI | None = None)

Bases: BaseSchema

address_line_1: str | None

address_line_2: str | None

avatar_uri: URI | None

city: str | None

country: str | None

first_name: str | None

last_name: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'address_line_1': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 1'), 'address_line_2': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 2'), 'avatar_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Avatar URI'), 'city': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='City'), 'country': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Country'), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='State'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone'), 'zip_code': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Zip code')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

phone_number: str | None

state: str | None

time_zone: str | None

zip_code: str | None

class app.schemas.CertificateCreate(*, title: str | None = None, issuer: str | None = None, expiration_date: datetime | None = None, issued_date: datetime | None = None)

Bases: BaseCertificate

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'expiration_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Expiration date of the certificate'), 'issued_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Issued date of the certificate'), 'issuer': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Issuer of the certificate'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Certificate title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.CertificateRead(*, id: UUID, created_at: datetime, updated_at: datetime, title: str | None = None, issuer: str | None = None, expiration_date: datetime | None = None, issued_date: datetime | None = None)

Bases: BaseCertificate, BaseRead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'expiration_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Expiration date of the certificate'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'issued_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Issued date of the certificate'), 'issuer': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Issuer of the certificate'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Certificate title'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.CertificateUpdate(*, title: str | None = None, issuer: str | None = None, expiration_date: datetime | None = None, issued_date: datetime | None = None)

Bases: BaseCertificate

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'expiration_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Expiration date of the certificate'), 'issued_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Issued date of the certificate'), 'issuer': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Issuer of the certificate'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Certificate title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ContactCreate(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, email: EmailStr | None = None, time_zone: str | None = None, notes: str | None = None)

Bases: BaseContact

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'email': FieldInfo(annotation=Union[EmailStr, NoneType], required=False, default=None, description='Email address'), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ContactRead(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, email: EmailStr | None = None, time_zone: str | None = None, notes: str | None = None, id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseRead, BaseContact

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'email': FieldInfo(annotation=Union[EmailStr, NoneType], required=False, default=None, description='Email address'), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ContactUpdate(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, email: EmailStr | None = None, time_zone: str | None = None, notes: str | None = None)

Bases: BaseContact

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'email': FieldInfo(annotation=Union[EmailStr, NoneType], required=False, default=None, description='Email address'), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ContentType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

CUSTOM = 'custom'

GENERATED = 'generated'

TEMPLATE = 'template'

class app.schemas.CoverLetterCreate(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None)

Bases: BaseCoverLetter

classmethod from_bytes(name: str, content: BytesIO) → CoverLetterRead

async classmethod from_pdf(filepath: str) → CoverLetterRead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Cover letter content type'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.CoverLetterRead(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None, id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseRead, BaseCoverLetter

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Cover letter content type'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter name'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.CoverLetterUpdate(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None)

Bases: BaseCoverLetter

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Cover letter content type'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Cover letter name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.EducationCreate(*, university: str | None = None, degree: str | None = None, gradePoint: str | None = None, activities: str | None = None, achievements: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None)

Bases: BaseEducation

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'achievements': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Achievements'), 'activities': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Activities involved'), 'degree': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Degree name'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the education'), 'gradePoint': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Grade point'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the education'), 'university': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='University name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.EducationRead(*, id: UUID, created_at: datetime, updated_at: datetime, university: str | None = None, degree: str | None = None, gradePoint: str | None = None, activities: str | None = None, achievements: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None)

Bases: BaseEducation, BaseRead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'achievements': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Achievements'), 'activities': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Activities involved'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'degree': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Degree name'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the education'), 'gradePoint': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Grade point'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the education'), 'university': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='University name'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.EducationUpdate(*, university: str | None = None, degree: str | None = None, gradePoint: str | None = None, activities: str | None = None, achievements: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None)

Bases: BaseEducation

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'achievements': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Achievements'), 'activities': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Activities involved'), 'degree': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Degree name'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the education'), 'gradePoint': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Grade point'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the education'), 'university': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='University name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExperienceCreate(*, title: str | None = None, company: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None, description: str | None = None, location: str | None = None, projects: str | None = None)

Bases: BaseExperience

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the experience'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the experience'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Location of the experience'), 'projects': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Projects involved'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the experience'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExperienceRead(*, id: UUID, created_at: datetime, updated_at: datetime, title: str | None = None, company: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None, description: str | None = None, location: str | None = None, projects: str | None = None)

Bases: BaseExperience, BaseRead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the experience'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the experience'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Location of the experience'), 'projects': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Projects involved'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the experience'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExperienceUpdate(*, title: str | None = None, company: str | None = None, start_date: datetime | None = None, end_date: datetime | None = None, description: str | None = None, location: str | None = None, projects: str | None = None)

Bases: BaseExperience

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the experience'), 'end_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='End date of the experience'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Location of the experience'), 'projects': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Projects involved'), 'start_date': FieldInfo(annotation=Union[datetime, NoneType], required=False, default=None, description='Start date of the experience'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorCreate(*, name: str | None = None, description: str | None = None, json_schema: dict | str | None = None, instruction: str | None = None, extractor_examples: list[ExtractorExampleRead] = [])

Bases: BaseExtractor

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor description'), 'extractor_examples': FieldInfo(annotation=list[ExtractorExampleRead], required=False, default=[], description='Extractor examples'), 'instruction': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor instruction'), 'json_schema': FieldInfo(annotation=Union[dict, str, NoneType], required=False, default=None, description='JSON schema'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorExampleCreate(*, content: str | None = None, output: str | None = None)

Bases: BaseExtractorExample

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example content'), 'output': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example output')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorExampleRead(*, content: str | None = None, output: str | None = None, id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseRead, BaseExtractorExample

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example content'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'output': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example output'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorExampleUpdate(*, content: str | None = None, output: str | None = None)

Bases: BaseExtractorExample

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example content'), 'output': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Example output')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorRead(*, name: str | None = None, description: str | None = None, json_schema: dict | str | None = None, instruction: str | None = None, extractor_examples: list[ExtractorExampleRead] = [], id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseRead, BaseExtractor

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor description'), 'extractor_examples': FieldInfo(annotation=list[ExtractorExampleRead], required=False, default=[], description='Extractor examples'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'instruction': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor instruction'), 'json_schema': FieldInfo(annotation=Union[dict, str, NoneType], required=False, default=None, description='JSON schema'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor name'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorRequest

Bases: BaseSchema

examples: list[ExtractorExampleRead]

instructions: str | None

json_schema: dict | None

llm_name: str | None

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'examples': FieldInfo(annotation=list[ExtractorExampleRead], required=False, default=[], description='Extraction examples'), 'instructions': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extraction instruction'), 'json_schema': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None, alias='schema', alias_priority=2, description='JSON schema'), 'llm_name': FieldInfo(annotation=Union[str, NoneType], required=False, default='gpt-3.5-turbo', description='Model name'), 'text': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Text to extract from')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

text: str | None

classmethod validate_schema(v: Any) → dict[str, Any]

Validate the schema.

class app.schemas.ExtractorResponse(*, data: list[Any] = [], content_too_long: bool = False)

Bases: BaseSchema

content_too_long: bool

data: list[Any]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content_too_long': FieldInfo(annotation=bool, required=False, default=False, description='Content too long to extract'), 'data': FieldInfo(annotation=list[Any], required=False, default=[], description='Extracted data')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ExtractorUpdate(*, name: str | None = None, description: str | None = None, json_schema: dict | str | None = None, instruction: str | None = None, extractor_examples: list[ExtractorExampleRead] = [])

Bases: BaseExtractor

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor description'), 'extractor_examples': FieldInfo(annotation=list[ExtractorExampleRead], required=False, default=[], description='Extractor examples'), 'instruction': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor instruction'), 'json_schema': FieldInfo(annotation=Union[dict, str, NoneType], required=False, default=None, description='JSON schema'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Extractor name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.LeadCreate(*, title: str | None = None, company: str | None = None, description: str | None = None, location: str | None = None, salary: str | None = None, job_function: str | None = None, industries: str | None = None, employment_type: str | None = None, seniority_level: str | None = None, education_level: str | None = None, notes: str | None = None, hiring_manager: str | None = None, url: str)

Bases: BaseLead

clean_and_wrap_text_fields() → Any

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job description'), 'education_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Required education level'), 'employment_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Type of employment'), 'hiring_manager': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Hiring manager'), 'industries': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Industries involved'), 'job_function': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job function'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job location'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'salary': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Salary range'), 'seniority_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Seniority level'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title'), 'url': FieldInfo(annotation=str, required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

url: str

class app.schemas.LeadRead(*, title: str | None = None, company: str | None = None, description: str | None = None, location: str | None = None, salary: str | None = None, job_function: str | None = None, industries: str | None = None, employment_type: str | None = None, seniority_level: str | None = None, education_level: str | None = None, notes: str | None = None, hiring_manager: str | None = None, id: UUID, created_at: datetime, updated_at: datetime, url: Url | str | None = None)

Bases: BaseRead, BaseLead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job description'), 'education_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Required education level'), 'employment_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Type of employment'), 'hiring_manager': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Hiring manager'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'industries': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Industries involved'), 'job_function': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job function'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job location'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'salary': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Salary range'), 'seniority_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Seniority level'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated'), 'url': FieldInfo(annotation=Union[Annotated[Url, UrlConstraints(max_length=None, allowed_schemes=['http', 'https'], host_required=None, default_host=None, default_port=None, default_path=None)], str, NoneType], required=False, default=None, description='Job posting URL')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

url: Url | str | None

class app.schemas.LeadUpdate(*, title: str | None = None, company: str | None = None, description: str | None = None, location: str | None = None, salary: str | None = None, job_function: str | None = None, industries: str | None = None, employment_type: str | None = None, seniority_level: str | None = None, education_level: str | None = None, notes: str | None = None, hiring_manager: str | None = None)

Bases: BaseLead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'company': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Company name'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job description'), 'education_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Required education level'), 'employment_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Type of employment'), 'hiring_manager': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Hiring manager'), 'industries': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Industries involved'), 'job_function': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job function'), 'location': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job location'), 'notes': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Additional notes'), 'salary': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Salary range'), 'seniority_level': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Seniority level'), 'title': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Job title')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.LeadsPaginatedRead(*, leads: Sequence[LeadRead], pagination: Pagination, total_count: int | None)

Bases: BaseSchema

leads: Sequence[LeadRead]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'leads': FieldInfo(annotation=Sequence[LeadRead], required=True), 'pagination': FieldInfo(annotation=Pagination, required=True), 'total_count': FieldInfo(annotation=Union[int, NoneType], required=True, description='Total number of leads, if pagination requested')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pagination: Pagination

total_count: int | None

class app.schemas.OrchestrationEventCreate(*, name: str | None = None, message: str | None = None, source_uri: URI | None = None, destination_uri: URI | None = None, status: OrchestrationEventStatusType | None = None, pipeline_id: UUID)

Bases: BaseOrchestrationEvent

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'destination_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Destination of the pipeline'), 'message': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Error message'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the event'), 'pipeline_id': FieldInfo(annotation=UUID, required=True, metadata=[UuidVersion(uuid_version=4)]), 'source_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Source of the pipeline'), 'status': FieldInfo(annotation=Union[OrchestrationEventStatusType, NoneType], required=False, default=None, description='Status of the event')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

pipeline_id: UUID

class app.schemas.OrchestrationEventRead(*, id: UUID, created_at: datetime, updated_at: datetime, name: str | None = None, message: str | None = None, source_uri: URI | None = None, destination_uri: URI | None = None, status: OrchestrationEventStatusType | None = None, pipeline_id: UUID | None = None)

Bases: BaseOrchestrationEvent, BaseRead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'destination_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Destination of the pipeline'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'message': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Error message'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the event'), 'pipeline_id': FieldInfo(annotation=Union[Annotated[UUID, UuidVersion], NoneType], required=False, default=None, description='Pipeline ID'), 'source_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Source of the pipeline'), 'status': FieldInfo(annotation=Union[OrchestrationEventStatusType, NoneType], required=False, default=None, description='Status of the event'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.OrchestrationEventStatusType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

FAILED = 'failure'

PENDING = 'pending'

RUNNING = 'running'

SUCCESS = 'success'

class app.schemas.OrchestrationEventUpdate(*, name: str | None = None, message: str | None = None, source_uri: URI | None = None, destination_uri: URI | None = None, status: OrchestrationEventStatusType | None = None, pipeline_id: UUID | None = None)

Bases: BaseOrchestrationEvent

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'destination_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Destination of the pipeline'), 'message': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Error message'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the event'), 'pipeline_id': FieldInfo(annotation=Union[Annotated[UUID, UuidVersion], NoneType], required=False, default=None, description='Pipeline ID'), 'source_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Source of the pipeline'), 'status': FieldInfo(annotation=Union[OrchestrationEventStatusType, NoneType], required=False, default=None, description='Status of the event')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.OrchestrationPipelineCreate(*, name: str | None = None, description: str | None = None, params: dict | None = None)

Bases: BaseOrchestrationPipeline

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the pipeline'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the pipeline'), 'params': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None, description='Parameters for the pipeline')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.OrchestrationPipelineRead(*, name: str | None = None, description: str | None = None, params: dict | None = None)

Bases: BaseOrchestrationPipeline, BaseRead

events: list[OrchestrationEventRead]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the pipeline'), 'events': FieldInfo(annotation=list[OrchestrationEventRead], required=False, default=[], alias='orchestration_events', alias_priority=2, description='Events in the pipeline'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the pipeline'), 'params': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None, description='Parameters for the pipeline'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.OrchestrationPipelineUpdate(*, name: str | None = None, description: str | None = None, params: dict | None = None)

Bases: BaseOrchestrationPipeline

events: list[OrchestrationEventRead]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description of the pipeline'), 'events': FieldInfo(annotation=list[OrchestrationEventRead], required=False, default=[], description='Events in the pipeline'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the pipeline'), 'params': FieldInfo(annotation=Union[dict, NoneType], required=False, default=None, description='Parameters for the pipeline')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.Pagination(*, page: int = 1, page_size: int = 10, request_count: bool = False)

Bases: BaseSchema

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'page': FieldInfo(annotation=int, required=False, default=1, description='The page number', metadata=[Ge(ge=1)]), 'page_size': FieldInfo(annotation=int, required=False, default=10, description='The number of items per page', metadata=[Ge(ge=1)]), 'request_count': FieldInfo(annotation=bool, required=False, default=False, description='Request a query for total count')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

page: int

page_size: int

request_count: bool

class app.schemas.ResumeCreate(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None)

Bases: BaseResume

async classmethod from_pdf(filepath: str | Path) → ResumeRead

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Resume content type'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ResumeRead(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None, id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseRead, BaseResume

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Resume content type'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume name'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.ResumeUpdate(*, name: str | None = None, content: str | None = None, content_type: ContentType | None = None)

Bases: BaseResume

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'content': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume content'), 'content_type': FieldInfo(annotation=Union[ContentType, NoneType], required=False, default=None, description='Resume content type'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Resume name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.SkillCreate(*, name: str | None = None, category: str | None = None, yoe: int | None = None, subskills: str | None = None)

Bases: BaseSkill

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Category of the skill'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the skill'), 'subskills': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Sub-Skills'), 'yoe': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, description='Years of Experience')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.SkillRead(*, name: str | None = None, category: str | None = None, yoe: int | None = None, subskills: str | None = None, id: UUID, created_at: datetime, updated_at: datetime)

Bases: BaseRead, BaseSkill

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Category of the skill'), 'created_at': FieldInfo(annotation=datetime, required=True, description='The time the item was created'), 'id': FieldInfo(annotation=UUID, required=True, description='The unique uuid4 record identifier.', metadata=[UuidVersion(uuid_version=4)]), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the skill'), 'subskills': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Sub-Skills'), 'updated_at': FieldInfo(annotation=datetime, required=True, description='The time the item was last updated'), 'yoe': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, description='Years of Experience')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.SkillUpdate(*, name: str | None = None, category: str | None = None, yoe: int | None = None, subskills: str | None = None)

Bases: BaseSkill

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'category': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Category of the skill'), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Name of the skill'), 'subskills': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Sub-Skills'), 'yoe': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, description='Years of Experience')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.URI(*, name: str, type: URIType)

Bases: BaseSchema

class Config

Bases: object

json_encoders = {'URI': <function URI.Config.<lambda>>}

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'json_encoders': {'URI': <function URI.Config.<lambda>>}, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True), 'type': FieldInfo(annotation=URIType, required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str

type: URIType

class app.schemas.URIType(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Bases: str, Enum

API = 'api'

DATABASE = 'database'

DATALAKE = 'datalake'

FILE = 'filepath'

class app.schemas.UserCreate(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, address_line_1: str | None = None, address_line_2: str | None = None, city: str | None = None, state: str | None = None, zip_code: str | None = None, country: str | None = None, time_zone: str | None = None, avatar_uri: URI | None = None, email: EmailStr, password: str, is_active: bool | None = True, is_superuser: bool | None = False, is_verified: bool | None = False)

Bases: BaseUserCreate, BaseUser

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'address_line_1': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 1'), 'address_line_2': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 2'), 'avatar_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Avatar URI'), 'city': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='City'), 'country': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Country'), 'email': FieldInfo(annotation=EmailStr, required=True), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'is_active': FieldInfo(annotation=Union[bool, NoneType], required=False, default=True), 'is_superuser': FieldInfo(annotation=Union[bool, NoneType], required=False, default=False), 'is_verified': FieldInfo(annotation=Union[bool, NoneType], required=False, default=False), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'password': FieldInfo(annotation=str, required=True), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='State'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone'), 'zip_code': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Zip code')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.UserProfileRead(*, skills: list[SkillRead] = [], experiences: list[ExperienceRead] = [], educations: list[EducationRead] = [], certificates: list[CertificateRead] = [])

Bases: BaseSchema

certificates: list[CertificateRead]

educations: list[EducationRead]

experiences: list[ExperienceRead]

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'certificates': FieldInfo(annotation=list[CertificateRead], required=False, default=[], description="User's certificates"), 'educations': FieldInfo(annotation=list[EducationRead], required=False, default=[], description="User's educational background"), 'experiences': FieldInfo(annotation=list[ExperienceRead], required=False, default=[], description="User's professional experiences"), 'skills': FieldInfo(annotation=list[SkillRead], required=False, default=[], description="User's skills")}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

skills: list[SkillRead]

class app.schemas.UserRead(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, address_line_1: str | None = None, address_line_2: str | None = None, city: str | None = None, state: str | None = None, zip_code: str | None = None, country: str | None = None, time_zone: str | None = None, avatar_uri: URI | None = None, id: UUID, email: EmailStr, is_active: bool = True, is_superuser: bool = False, is_verified: bool = False)

Bases: BaseUser[Annotated[UUID, UuidVersion]], BaseUser

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'address_line_1': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 1'), 'address_line_2': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 2'), 'avatar_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Avatar URI'), 'city': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='City'), 'country': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Country'), 'email': FieldInfo(annotation=EmailStr, required=True), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'id': FieldInfo(annotation=Annotated[UUID, UuidVersion], required=True), 'is_active': FieldInfo(annotation=bool, required=False, default=True), 'is_superuser': FieldInfo(annotation=bool, required=False, default=False), 'is_verified': FieldInfo(annotation=bool, required=False, default=False), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='State'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone'), 'zip_code': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Zip code')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class app.schemas.UserUpdate(*, first_name: str | None = None, last_name: str | None = None, phone_number: str | None = None, address_line_1: str | None = None, address_line_2: str | None = None, city: str | None = None, state: str | None = None, zip_code: str | None = None, country: str | None = None, time_zone: str | None = None, avatar_uri: URI | None = None, password: str | None = None, email: EmailStr | None = None, is_active: bool | None = None, is_superuser: bool | None = None, is_verified: bool | None = None)

Bases: BaseUserUpdate, BaseUser

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'from_attributes': True, 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'address_line_1': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 1'), 'address_line_2': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Address line 2'), 'avatar_uri': FieldInfo(annotation=Union[URI, NoneType], required=False, default=None, description='Avatar URI'), 'city': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='City'), 'country': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Country'), 'email': FieldInfo(annotation=Union[EmailStr, NoneType], required=False, default=None), 'first_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='First name'), 'is_active': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_superuser': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'is_verified': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'last_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Last name'), 'password': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'phone_number': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Phone number'), 'state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='State'), 'time_zone': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Time zone'), 'zip_code': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Zip code')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Indices and tables

• Index

• Module Index

• Search Page