Skip to content

Index

YouSleep Pydantic models and data validation.

See also the yousleep_common.types module for common data types (enums, annotated primitives etc.)

API_KEY_PREFIX = 'ysk_' module-attribute

Every API key starts with this; the server recognises a key by it.

CalendarGranularity = Literal['day', 'week', 'month'] module-attribute

The span of one calendar bin.

LongitudinalBasis = Literal['session-index', 'calendar'] module-attribute

What a bin is: a position within the subject's series, or a calendar span.

LongitudinalRegime = Literal['derived', 'declared'] module-attribute

Where session positions came from; set on session-index sections only.

MAX_BATCH_ANALYSIS_IDS = 100 module-attribute

Analysis ids in one batch cancel, status poll, events or blocks read.

MAX_BATCH_ANALYSIS_ITEMS = 500 module-attribute

Analyses (targets × pipeline steps) in one batch submission.

MAX_BATCH_CHANNEL_PATCHES = 200 module-attribute

Patches in one bulk channel patch.

MAX_BATCH_RECORDING_IDS = 100 module-attribute

Recording ids in one batch recording-details read.

MAX_BATCH_STUDY_IDS = 100 module-attribute

Study ids in one batch recordings-by-studies or studies-by-ids read.

MAX_BATCH_STUDY_ITEMS = 500 module-attribute

Studies created, metadata patches or lights assignments in one request.

NOT_SET_STRATUM_LABEL = 'Not set' module-attribute

Stratum label for studies missing the stratified metadata factor.

Contract, not a display nicety: a stratified report accounts for every study, so studies without the factor form their own stratum under this exact label — the parallel of UNTAGGED_GROUP_LABEL for tag grouping. Ordered last.

REDACTED_DETAIL_KEYS = frozenset({'email_hash'}) module-attribute

Keys an audit event's detail never carries on the wire.

The one-way email hash a deleted account leaves behind exists so a support lookup by address can find the row; the lookup is a server-side filter, and the hash itself is never handed out.

STUDY_IMPORT_COLUMNS = [StudyImportColumn(key='study', kind='study_key', aliases=['study', 'study_name', 'name', 'study_id', 'id'], description='The study each row addresses, by exact name or id. Required.'), StudyImportColumn(key='subject_key', kind='text', aliases=['subject_key', 'subject', 'subject_id', 'subject_code', 'participant', 'participant_id'], description="The person the study belongs to. Rows sharing a key within the project form one subject's series. Compared case- and whitespace-insensitively; blank leaves the study standing alone."), StudyImportColumn(key='session_index', kind='integer', aliases=['session_index', 'session', 'night', 'night_index', 'visit', 'visit_index'], description="Declared position of the study in its subject's series, 1 = first. Blank orders by recording start instead. A subject whose studies are only partly numbered is left out of session-indexed figures and named in a warning."), StudyImportColumn(key='age', kind='integer', aliases=['age', 'age_years', 'subject_age'], unit='years', description='Subject age in years (0–125). NULL clears.'), StudyImportColumn(key='sex', kind='sex', aliases=['sex', 'gender'], description="Subject sex (the platform's Sex vocabulary). NULL clears."), StudyImportColumn(key='bmi', kind='decimal', aliases=['bmi', 'body_mass_index'], unit='kg/m²', description='Body mass index (5–200). NULL clears.'), StudyImportColumn(key='lights_off_clock', kind='clock', aliases=['lights_off', 'lights_off_clock', 'lights off', 'loff'], description="Lights-off as wall clock HH:MM[:SS] in the recording's own frame, resolved with overnight wrap. Only valid while the study's recording span is ≤ 24 h — longer spans must use the datetime or ms spelling."), StudyImportColumn(key='lights_on_clock', kind='clock', aliases=['lights_on', 'lights_on_clock', 'lights on', 'lon'], description='Lights-on as wall clock HH:MM[:SS], resolved with overnight wrap after lights-off.'), StudyImportColumn(key='lights_off_datetime', kind='datetime', aliases=['lights_off_datetime', 'lights_off_at'], description="Lights-off as an absolute datetime in the recording's wall-clock frame (alternate spelling)."), StudyImportColumn(key='lights_on_datetime', kind='datetime', aliases=['lights_on_datetime', 'lights_on_at'], description='Lights-on as an absolute datetime (alternate spelling).'), StudyImportColumn(key='lights_off_ms', kind='elapsed_ms', aliases=['lights_off_ms', 'lights_off_elapsed_ms'], unit='ms', description='Lights-off as milliseconds from recording start (alternate spelling).'), StudyImportColumn(key='lights_on_ms', kind='elapsed_ms', aliases=['lights_on_ms', 'lights_on_elapsed_ms'], unit='ms', description='Lights-on as milliseconds from recording start (alternate spelling).')] module-attribute

The one column table: frontend auto-mapping, SDK docs, and the template download all derive from this — never duplicate it.

StudyOrder = Literal['created', 'subject'] module-attribute

How a study listing is ordered.

created is the order the studies were created in — the default, and what pagination has always walked. subject puts a person's studies together and in series order: subjects in key order, within a subject the declared visit numbers first and unnumbered nights after them, and the studies that belong to no subject last. A paginated listing ordered this way can be read (and drawn) grouped by person.

AccessToken pydantic-model

Bases: BaseModel

Access token details.

Fields:

  • access_token (str)
  • access_token_expires_utc_seconds (int)
  • user_id (UUID7)

AdminAnalysisConfigOut pydantic-model

Bases: BaseModel

An analysis in the registry, and who it is offered to.

Fields:

origin pydantic-field

Who developed it, as its provenance declares.

owner_org_id = None pydantic-field

The organization whose members see and run it while it is private.

promoted_at = None pydantic-field

When it was published; null if it never was.

promotion_refused = None pydantic-field

Why a promotion would be refused now; null when it would be accepted.

AdminAnalysisConfigUpdate pydantic-model

Bases: BaseModel

Change who an analysis is offered to. Omitted fields stay as they are.

visibility moves an analysis one way: private to public is a promotion, and either to withdrawn is a withdrawal. Nothing returns to private; a changed analysis is registered as a new version.

Fields:

owner_org_id = None pydantic-field

The organization that may see and run it while it is private; an explicit null removes the owner.

visibility = None pydantic-field

public to promote, withdrawn to withdraw.

AdminAnalysisFilter pydantic-model

Bases: _FilterBase

Predicate over every analysis on the platform; at least one field must be set.

Mirrors the admin analysis list endpoint's filter query parameters. The server applies it to live, not-yet-settled analyses only when the operation is a cancellation, so a filter can never address a finished run.

Fields:

Validators:

  • _at_least_one_predicate

status_any = None pydantic-field

Match analyses in at least one of these states.

user_id = None pydantic-field

Match analyses owned by this account.

AdminAnalysisListResponse pydantic-model

Bases: PaginatedResponse

A page of analyses across accounts, newest first.

Fields:

AdminAnalysisOut pydantic-model

Bases: AnalysisIdMixin, AnalysisStatusMixin, AnalysisTimingMixin

An analysis as an administrator operates on it.

Its status, timing, owner, cost and outcome, and the ids of what it ran on. Never the names people gave their projects, studies or files, which operating the platform does not need.

Config:

  • from_attributes: True

Fields:

analysis_config_id pydantic-field

ID of the analysis configuration used for the analysis.

analysis_config_name pydantic-field

Name of the analysis configuration used for the analysis.

analysis_hours pydantic-field

Signal hours the analysis was priced on.

cost pydantic-field

Credits charged for the analysis, or held while it is live.

deleted_at = None pydantic-field

When the analysis was deleted, for listings that include deleted rows. Null for live analyses.

exit_code = None pydantic-field

Exit code of the analysis process, once it has run.

org_id = None pydantic-field

The owning organization. Null when it was erased.

project_id = None pydantic-field

ID of the project the analysis belongs to. None if deleted.

recording_id = None pydantic-field

ID of the recording the analysis ran on. None if deleted.

user_email = None pydantic-field

The owning account's email. Null when that account was erased.

user_id = None pydantic-field

The owning account. Null when that account was erased.

AdminAnalysisSelector pydantic-model

Bases: _SelectorBase

Address a set of analyses across accounts: one of ids | filter | all.

all addresses every live analysis on the platform and, like every live-set mode, must state the count the caller resolved.

Fields:

Validators:

  • _exactly_one_mode

filter = None pydantic-field

Server-resolved predicate (live set).

AdminCancelAnalysesRequest pydantic-model

Bases: BaseModel

Cancel analyses across accounts.

Addresses its subjects with a selector. Only live, not-yet-settled analyses are cancelled; a finished one addressed by id is reported as an error, and a filter never resolves to one.

Fields:

Validators:

  • _guard

expected_count = None pydantic-field

Required for live-set selectors (filter/all): the resolved count the caller saw on the admin analysis list. The server re-resolves and rejects on a mismatch.

AdminCancelAnalysesResponse pydantic-model

Bases: BaseModel

Outcome of one page of an admin cancellation.

Fields:

AdminCancelSummary pydantic-model

Bases: BatchCancelSummary

Counts for one page of an admin cancellation.

Fields:

  • total (int)
  • cancelled (int)
  • errors (int)
  • remaining (int)

remaining pydantic-field

Live analyses the selector still addresses after this page. Call again with the same selector until this is zero; each call handles at most the server's per-request cap.

AdminCapabilityRequestDecline pydantic-model

Bases: BaseModel

Decline a request for a capability, with the reason the organisation is shown.

Fields:

  • reason (str)

AdminCapabilityRequestOut pydantic-model

Bases: CapabilityRequestOut

A request for a capability as administrators see it: with its organisation.

Fields:

AdminCapabilityRequestPage pydantic-model

Bases: BaseModel

One page of requests for capabilities across organisations, pending first, oldest first.

Config:

  • frozen: True

Fields:

AdminCreditRequestApprove pydantic-model

Bases: BaseModel

Approve a grant or extension request, as asked or with changes.

Fields:

amount = None pydantic-field

Credits to grant; null grants the amount requested. Ignored for an extension.

note = None pydantic-field

Recorded with the decision for administrators; never sent.

term_months = None pydantic-field

The term to grant or extend by; null keeps the requested one.

AdminCreditRequestDecline pydantic-model

Bases: BaseModel

Decline a grant or extension request, with a reason the requester is sent.

Fields:

note = None pydantic-field

Recorded with the decision for administrators; never sent.

notify = True pydantic-field

Email the requester the decision and its reason.

AdminCreditRequestOut pydantic-model

Bases: CreditRequestOut

A request as administrators see it: with its organization and the decision's note.

Fields:

AdminCreditRequestPage pydantic-model

Bases: BaseModel

One page of requests across organizations, pending first, oldest first.

Config:

  • frozen: True

Fields:

AdminDemoDatasetCreate pydantic-model

Bases: BaseModel

Request body for POST /admin/demo-datasets.

Fields:

  • name (str)
  • full_name (str)
  • description (str)
  • version (str)
  • source_name (str)
  • source_url (HttpUrl)
  • licence_name (str)
  • licence_url (HttpUrl)
  • studies (list[DemoStudyCreate])

AdminDemoDatasetOut pydantic-model

Bases: BaseModel

Admin-facing response for a demo dataset.

Fields:

  • id (UUID)
  • name (str)
  • full_name (str)
  • description (str)
  • version (str)
  • source_name (str)
  • source_url (HttpUrl)
  • licence_name (str)
  • licence_url (HttpUrl)
  • study_count (int)
  • recording_count (int)
  • created_at (datetime)
  • updated_at (datetime)

AdminEntitlementChange pydantic-model

Bases: BaseModel

Turn one of an organisation's capabilities on or off.

On needs the owner's acceptance of the latest published site agreement, unless the platform operates the organisation itself. Off is always allowed; it stops new work at the organisation's site, and nothing already there is touched.

Fields:

reason pydantic-field

Why, for the organisation's audit trail and the administrators.

AdminGrantCreate pydantic-model

Bases: BaseModel

Research credits an administrator grants an organization directly.

Fields:

amount pydantic-field

Credits to grant.

reason pydantic-field

Why the credits are granted (kept with the grant).

term_months = None pydantic-field

How long the grant lasts, from the offered terms; null for a grant that never expires.

AdminHealthDetail pydantic-model

Bases: BaseModel

The API's health, dependency by dependency.

The public health endpoint reports only the overall status. This breakdown is for operators. It is always returned with 200; the status fields carry the diagnosis.

Fields:

  • status (Literal['ok', 'degraded', 'unhealthy'])
  • postgres (Literal['ok', 'error'])
  • redis (Literal['ok', 'error'])
  • runners (Literal['ok', 'none seen'])

postgres pydantic-field

Whether the database answers a trivial query in time.

redis pydantic-field

Whether Redis answers a ping in time.

runners pydantic-field

Whether an approved runner has asked for work in the last few minutes.

status pydantic-field

ok when every dependency answers and a runner has been seen recently; degraded when no runner has, so analyses wait but everything else works; unhealthy when the database or Redis does not answer.

AdminOrganizationDetailOut pydantic-model

Bases: AdminOrganizationOut

One organization with its members, as the operators see it.

Fields:

capabilities = None pydantic-field

Its capabilities on its own hardware, and the site agreement they rest on.

members pydantic-field

Every member, owner first.

AdminOrganizationListResponse pydantic-model

Bases: PaginatedResponse

Paginated organization list response.

Fields:

AdminOrganizationOut pydantic-model

Bases: BaseModel

An organization as the operators list it.

Identity, owner, seats, projects, storage and credits in one row, with the overrides an administrator may set and the values actually in force. Retired organizations (deleted_at set) are listed only on request.

Config:

  • from_attributes: True

Fields:

analyses_at_site = False pydantic-field

Whether the organisation's analyses run at its site.

credits pydantic-field

The organization's credit balance.

deleted_at = None pydantic-field

When the organization was retired, if it was.

effective_project_limit = None pydantic-field

The projects the organization may hold — the override, else the configured default; null when uncapped.

effective_seat_limit = None pydantic-field

The seat limit in force — the override, else the configured default; null when uncapped.

effective_site_compute_factor = 0 pydantic-field

The factor in force on the platform price for analyses run at the organisation's site: the override, else the platform's.

effective_storage_ceiling_gb = 0 pydantic-field

The storage ceiling in force (GB).

effective_study_limit = None pydantic-field

The studies one project may hold — the override, else the configured default, never above the platform's ceiling.

owner_user_id = None pydantic-field

The owner's user id (every live organization has one).

pending_invitation_count = 0 pydantic-field

Invitations sent and not yet accepted, revoked or expired.

platform_operated = False pydantic-field

Whether the platform operates the organisation itself.

project_limit = None pydantic-field

The project-limit override, if set.

recordings_at_site = False pydantic-field

Whether the organisation's new projects keep their recordings in its bucket.

seat_limit = None pydantic-field

The seat-limit override, if set.

site_compute_factor = None pydantic-field

The site-compute factor override, if set.

storage_bytes = 0 pydantic-field

Bytes held against the organization's storage ceiling.

storage_ceiling_gb = None pydantic-field

The storage-ceiling override (GB), if set.

storage_insolvent_since = None pydantic-field

When the balance stopped covering the storage debit; null = solvent.

study_limit = None pydantic-field

The per-project study-limit override, if set.

AdminOrganizationUpdate pydantic-model

Bases: BaseModel

An administrator's change to an organization's limits and settings.

Each limit, and the site-compute factor, is an override of the platform's configured default: a value sets it, an explicit null clears it (back to the default), and an omitted field is left unchanged. Servers distinguish the last two through model_fields_set. An unknown field is refused, not ignored.

Config:

  • extra: forbid

Fields:

Validators:

  • _switches_are_set_or_left

analyses_at_site = None pydantic-field

Whether the organisation's analyses run at its site. Turning it on needs site compute and an approved runner of the organisation's site pool taking work. It takes effect at the next submission; an analysis already queued stays where it is. It cannot be cleared to null.

platform_operated = None pydantic-field

Whether the platform operates the organisation itself, as for a demonstration site. Such an organisation's capabilities are turned on without an acceptance of the site agreement. It cannot be cleared to null.

project_limit = None pydantic-field

Projects the organization may hold.

recordings_at_site = None pydantic-field

Whether the organisation's new projects keep their recordings in its registered bucket. Turning it on needs site storage, analyses at the site, and a bucket whose browser check passed with its current key. Existing projects keep where they are stored. It cannot be cleared to null.

seat_limit = None pydantic-field

Members plus pending invitations the organization may hold.

site_compute_factor = None pydantic-field

The organisation's own factor on the platform price for analyses run at its site, as its agreement sets it. Null clears it back to the platform's factor.

storage_ceiling_gb = None pydantic-field

The storage the organization may use (GB).

study_limit = None pydantic-field

Studies one of the organization's projects may hold, at most the platform's ceiling.

AdminOwnershipTransfer pydantic-model

Bases: BaseModel

Hand an organization to one of its members, by an administrator.

The recovery path for an organization whose owner is unreachable: the current owner becomes an admin and both are told by email. Audited with the administrator as the actor.

Fields:

new_owner_user_id pydantic-field

The member who becomes the owner.

AdminPendingInvitation pydantic-model

Bases: BaseModel

An open invitation addressed to an account's email, as the admin views show it.

Tells an administrator reviewing an applicant who asked them to join, and into which organization, before the account is approved.

Config:

  • frozen: True

Fields:

created_at pydantic-field

When it was sent.

expires_at pydantic-field

When it stops being acceptable.

id pydantic-field

Unique identifier of the invitation.

invited_by_email = None pydantic-field

Email of the member who sent it; null when that account was deleted.

invited_by_id = None pydantic-field

The member who sent it; null when that account was deleted.

invited_by_name = None pydantic-field

Display name of the member who sent it, if set.

organization_id pydantic-field

The organization that sent it.

organization_name pydantic-field

The organization's display name.

role pydantic-field

The role the invitee would join with.

AdminQueueSummary pydantic-model

Bases: BaseModel

The queue in one read.

What is live, how long the oldest has waited, and who holds it.

Fields:

by_status pydantic-field

Live analyses by status; statuses with none are absent.

oldest_waiting_seconds = None pydantic-field

Age of the oldest analysis still waiting to run (pending or enqueued), or null when nothing waits.

per_user pydantic-field

Accounts holding live analyses, most first, capped by the server.

sampled_at pydantic-field

When this summary was read.

AdminQueueUserShare pydantic-model

Bases: BaseModel

One account's share of the live analyses.

Fields:

active pydantic-field

Live, not-yet-settled analyses.

user_email = None pydantic-field

Null when the account was erased while its analyses were still live.

AdminUserCreate pydantic-model

Bases: BaseModel

Admin user creation request.

Fields:

Validators:

  • _require_password_unless_generated

confirm_email = True pydantic-field

Whether to pre-confirm the user's email address.

credits = 0 pydantic-field

Research credits granted to the new account's organization on top of its starter grant; they never expire.

email pydantic-field

Email address for the new user.

generate_password = False pydantic-field

If true, ignore password, generate a strong random password, and email the user a one-time link to set their own password. The email is always pre-confirmed in this mode so the setup link can be delivered.

name = None pydantic-field

The new user's name. Defaults to the email local-part if omitted (admin-provisioned accounts are not request-access applicants).

organization = None pydantic-field

Organization the user belongs to.

password = None pydantic-field

Password for the new user. Required unless generate_password is set, in which case any supplied value is ignored.

permissions = None pydantic-field

Permissions for the new user. None uses config defaults.

position = None pydantic-field

Position of the user in their organization.

role = Role.USER pydantic-field

Authorization role for the new user (user or admin).

AdminUserListResponse pydantic-model

Bases: PaginatedResponse

Paginated user list response.

Fields:

AdminUserOut pydantic-model

Bases: UserOut

An account as the operators see it.

The account's own settings and state. What belongs to its organization (limits, overrides, the credit balance) is read and set on the organization: :class:AdminOrganizationOut.

Config:

  • from_attributes: True

Fields:

can_create_api_keys pydantic-field

Whether the account may create API keys — it holds the api-key-create permission. Granted by an administrator; server-derived from the permission set, never stored separately.

can_submit pydantic-field

Whether the account may submit analyses — it holds the analysis-create permission, directly or through the wildcard. Server-derived from the permission set, never stored separately.

can_upload pydantic-field

Whether the account may register recordings — it holds the recording-create permission, directly or through the wildcard. Server-derived from the permission set, never stored separately.

pending_invitations pydantic-field

Open invitations addressed to the account's email: not accepted, not revoked, not expired, from an organization that still exists. Shows who invited an applicant awaiting approval, and where to.

AdminUserReject pydantic-model

Bases: BaseModel

An admin's decision to decline an access request.

reason is chosen from a fixed list and is what the applicant is told. note is the reviewer's own words: it is recorded with the decision and is never sent, because an explanation written for a colleague should not become an external statement about a named person.

Fields:

note = None pydantic-field

The reviewer's note, for the audit record. Never sent to the applicant.

notify = True pydantic-field

Whether to email the applicant. Leave true unless there is a reason not to reach this address at all.

reason pydantic-field

Why the request was declined. The applicant is told this, in the platform's own wording, unless the reason carries no detail.

AdminUserUpdate pydantic-model

Bases: BaseModel

Admin user update request; an omitted field is left unchanged.

The account's own settings only: an organization's limits and credits are set on the organization (:class:AdminOrganizationUpdate, :class:CreditAdjustment). An unknown field is refused, not ignored, so a limit sent here fails instead of silently changing nothing.

Config:

  • extra: forbid

Fields:

Validators:

  • _switches_or_permissions

can_create_api_keys = None pydantic-field

Grant (true) or withdraw (false) the ability to create API keys. Same mechanism as can_upload, on the api-key-create permission. Withdrawing leaves existing keys working and revocable; it stops new ones. Cannot be combined with permissions in one request.

can_submit = None pydantic-field

Grant (true) or withdraw (false) the ability to submit analyses. Same mechanism as can_upload, on the analysis-create permission. Cannot be combined with permissions in one request.

can_upload = None pydantic-field

Grant (true) or withdraw (false) the ability to register recordings. The server edits the permission set accordingly — withdrawing expands a wildcard grant into its other members — so this is the same gate the recording routes check, not a second one. Cannot be combined with permissions in one request.

disabled = None pydantic-field

Whether to disable or enable the user.

email = None pydantic-field

New email address.

organization = None pydantic-field

New organization.

password = None pydantic-field

New password.

permissions = None pydantic-field

New permissions list.

position = None pydantic-field

New position.

role = None pydantic-field

New authorization role (user or admin).

usage_type = None pydantic-field

New usage type. Switching changes which licence the user must consent to (they are re-gated on the new licence) and which analysis configs they may run — but outputs keep the licence they were produced under.

AnalysisBiomarkersResponse pydantic-model

Bases: BiomarkerResult

A single analysis's biomarker result plus its presentation table.

Extends BiomarkerResult (so existing consumers of the analysis biomarkers endpoint keep working unchanged) with the server-defined TableModel that renders it — formatted values, curated summary flags, and any configured status tokens.

Fields:

table = None pydantic-field

Server-defined presentation table for the result. None for producers predating the field.

AnalysisConfig pydantic-model

Bases: AnalysisConfigBase

The full analysis configuration: what is stored, hashed and run.

Adds what the catalogue does not serve: the image, the scheduling priority and the resources the analysis claims.

Config:

  • frozen: True

Fields:

Validators:

priority pydantic-field

Scheduling priority. A platform decision; an author leaves it out.

compute_config_sha1()

Compute the SHA1 hash of the analysis configuration JSON serialized.

load_validated_analysis_config(config_id, configs_dir) classmethod

Load and validate an analysis configuration from a YAML file by its filename.

:param config_id: ID of the analysis configuration file. :param configs_dir: Directory where the analysis configuration files are stored. :return: Validated analysis configuration.

AnalysisConfigBase pydantic-model

Bases: BaseModel

What an analysis configuration says that anyone may read.

The shared part of two models: AnalysisConfig, the full configuration that is stored, hashed and run, and AnalysisConfigOut, what the catalogue serves. What the platform knows about an analysis rather than what the configuration says (whether its image is present, who it is offered to) lives on the response model only, so it never enters a configuration's identity.

Fields:

Validators:

cost pydantic-field

Declarative pricing facts (work scaling + parameter surcharges). Defaults = flat per-signal-hour pricing; the quote endpoints always report the final figure.

evidence pydantic-field

What the analysis cites. An analysis with nothing to cite yet omits it.

identification pydantic-field

The identification object of the analysis configuration

licence pydantic-field

The licence of the analysis.

parameters pydantic-field

Parameters the analysis accepts. Omitted when it takes none.

provenance pydantic-field

Who developed the analysis, and what youSleep claims about it.

purpose pydantic-field

The purpose of the analysis.

runs_at pydantic-field

Where the analysis may run: on the platform, or on the platform and at an organisation's site. Its owner sets it, and a change applies to submissions made after it. Left out when it is the platform only. An organisation may run a platform-only analysis at its site only under an exception a platform administrator records.

runs_on_the_platform(runs_at) pydantic-validator

Require the platform among the places, and keep them in one order.

Every analysis runs on the platform; a site is the only addition. The order is fixed so two configurations that say the same thing hash the same.

the_declaration_covers_the_licence_class() pydantic-validator

Refuse a commercial licence class on a declaration that ticked non-commercial use.

The declaration is what the developer said the analysis may be offered for; the licence class is what the platform offers it for. The second cannot exceed the first.

validated_regime_is_yousleeps_own_claim() pydantic-validator

Refuse a validated regime on an analysis youSleep did not develop.

The regime says which values of a parameter the analysis was characterised at, and the platform says it in its own voice: every other value is then presented to the user as a research setting. That is a claim to make about one's own work. A developer's published operating point for their own analysis belongs under evidence, where a reader can see whose claim it is, rather than being restated here as the platform's.

AnalysisConfigOut pydantic-model

Bases: AnalysisConfigBase

What the catalogue serves: the readable configuration and the platform's facts about it.

Fields:

Validators:

available = False pydantic-field

Whether the analysis's image is present in the registry, as the platform last checked.

credit property

Return the credit this analysis's results carry, wherever they are shown.

credits_per_signal_hour = 0 pydantic-field

What the analysis costs per hour of recorded signal, before channel and parameter adjustments, as the platform charges it.

site_allowance = None pydantic-field

Where the caller's organisation may run the analysis, for a signed-in caller. Null for an anonymous caller, and from a server that predates it.

spend_class property

Return the spend class the analysis's licence gives it.

visibility = AnalysisVisibility.PUBLIC pydantic-field

Where the analysis is offered. A caller sees a private analysis only when it belongs to the caller's organization.

AnalysisFilter pydantic-model

Bases: _FilterBase

Predicate over a project's analyses; at least one field must be set.

Fields:

Validators:

  • _at_least_one_predicate

analysis_config_id = None pydantic-field

Match analyses of this analysis configuration.

status_any = None pydantic-field

Match analyses in at least one of these states.

AnalysisListResponse pydantic-model

Bases: PaginatedResponse

A page of analyses, of a project or of a recording.

Fields:

AnalysisLogs pydantic-model

Bases: BaseModel

Logs of an analysis.

Fields:

stderr pydantic-field

Standard error logs of the analysis.

stdout pydantic-field

Standard output logs of the analysis.

AnalysisManifest pydantic-model

Bases: BaseModel

The document an analysis container receives, and nothing else.

Config:

  • extra: forbid
  • frozen: True

Fields:

Validators:

  • _consistent

parameters pydantic-field

Custom parameters by key, typed as the configuration declared them.

slots pydantic-field

Ordered labelled input positions; empty for type-only requirements.

json_schema() classmethod

Return the JSON schema of the manifest, for containers in other languages.

AnalysisOut pydantic-model

Bases: AnalysisIdMixin, AnalysisStatusMixin, AnalysisTimingMixin

Analysis information available to user.

Combines identification, timing, context annotations, and cost fields into a single flat response model.

Fields:

analysis_config_id pydantic-field

ID of the analysis configuration used for the analysis.

analysis_config_name pydantic-field

Name of the analysis configuration used for the analysis.

analysis_hours = 0 pydantic-field

Number of hours of recording analysed.

analysis_types pydantic-field

List of analysis types the analysis performed.

channels = None pydantic-field

Channels used in the analysis. None if all available channels were used.

cost = 0 pydantic-field

Cost of the analysis.

cost_currency = Currency.CREDITS pydantic-field

The currency of the cost.

deleted = False pydantic-field

Flag indicating if the analysis has been deleted

owner_id = None pydantic-field

The member who added it. Only they, or the project's owner, may change or remove it; it passes to the project's owner when they leave the organization.

parameter_hash = None pydantic-field

SHA-1 hash of the analysis parameters (config ID + parameters + dependencies + channels).

parameters pydantic-field

Parameters used in the analysis.

project_id = None pydantic-field

ID of the project the analysis belongs to. None if deleted.

project_name = None pydantic-field

Name of the project the analysis belongs to. None if deleted.

recording_file_name = None pydantic-field

Name of the recording file the analysis was performed on. None if deleted.

recording_id = None pydantic-field

ID of the recording the analysis was performed on. None if deleted.

research_parameters = None pydantic-field

Parameters (by API name) whose value lay outside the analysis configuration's validated regime. A non-empty list marks this analysis as run in research mode: fully supported, but its outputs are exploratory because the analysis was not characterised at those values. Empty when every parameter was within the regime (or no regime is declared). None when not derived — the value could not be resolved against the configuration.

study_id = None pydantic-field

ID of the study the analysis belongs to. None if deleted.

study_name = None pydantic-field

Name of the study the analysis belongs to. None if deleted.

AnalysisParameter pydantic-model

Bases: BaseModel

Represents an analysis-specific parameter.

Analysis parameters are used to configure the analysis and can be of type 'str', 'int', or 'float'. Can be set by the user unless there is only a single choice in which case it is considered a hard coded parameters.

Fields:

Validators:

api_name property

Return the name a request uses for this parameter: its key.

Kept as a computed field so the API schema and every client keep the name they have always read; it is the key by another name.

choices = None pydantic-field

The list of choices for the parameter. If set, the parameter is considered a choice parameter and the user must select one of the choices. If choises is a length 1 list the parameter is considered a hard coded parameter and the user cannot change the value. Must be set if range is not set.

default pydantic-field

The default value of the parameter. Must be one of the choices if choices is set or must be in range if range is set. REQUIRED: All parameters must have a default for consistent hash computation.

description pydantic-field

A brief description of the parameter.

key pydantic-field

The machine key of the parameter, unique within the analysis: what a request names it by, the key it has in the analysis manifest's parameters, and the name the parameter hash is computed over. Lowercase letters, digits, hyphens and underscores.

name pydantic-field

The name of the parameter. Must be unique among all parameters of the analysis. The name must be a contain only lowercase alphabetical characters and underscores ('_') and be between 2 and 32 characters long.

range = None pydantic-field

The range of acceptable values for the parameter. Must be set if choices is not set.

type pydantic-field

The type of the parameter. Can be 'str', 'int', 'float', or 'bool'.

validated_regime = None pydantic-field

The value(s) of this parameter at which the analysis has been validated — its validated regime. Every other accepted value stays fully supported and runnable, but is a research setting: the analysis was not characterised there, so its outputs are exploratory and should be interpreted as such. This is a different statement from 'default', which only says which value is pre-selected for the user; an analysis may pre-select a value it was never validated at, or be validated at several values of which only one is pre-selected. List every validated value when more than one qualifies. Leave unset (null) when the validated regime is not declared, in which case no value is claimed to be a research setting and none is claimed to be validated. Each entry must be an accepted value of this parameter: one of 'choices', or inside 'range'.

get_validated_value_or_default(value)

Return the value if it is not None, otherwise return the default value.

Every parameter declares a default, so a value is always returned.

is_research_mode(value)

Return whether value falls outside this parameter's validated regime.

Always False when no validated regime is declared: an undeclared regime makes no claim about any value, so nothing is presented as research mode.

Pass a normalized value — the output of :meth:validate_value or :meth:get_validated_value_or_default. A raw, uncoerced submission such as the string "3840" does not match the integer 3840 and would be reported as research.

validate_choices(choices) pydantic-validator

Validate that all choices are unique and of the same type.

validate_default() pydantic-validator

Validate that the default value is one of the choices if choices is set.

validate_range(range) pydantic-validator

Validate that the range values are of the same type and either int or float.

validate_range_choices(data) pydantic-validator

Validate the range and choices fields.

Validate that only one of 'range' and 'choices' can be set and that at least one of them is set.

validate_validated_regime() pydantic-validator

Validate that every declared validated-regime value is an accepted value.

A validated regime that names a value the parameter does not accept could never be selected, so it would silently mark every selectable value as research mode.

validate_value(value)

Validate the value of the parameter and return the value if it is valid.

AnalysisRequest pydantic-model

Bases: BaseModel

Analysis request information.

Fields:

Validators:

analysis_config_id pydantic-field

The unique analysis config type identifier (e.g., 'u-sleep-research-v1')

channels = None pydantic-field

Optional list of specific channels (by name) to use in the analysisIf not specified, all channels of types and/or exact match to the analysis' requirements available on the study will be used.

dependencies pydantic-field

A list of 2-tuples of format (parameter_hash, list of typed events) where parameter_hash identifies a dependency analysis by its parameter hash (SHA-1 hex string), and typed events specify which events are required as input from that dependency. The present analysis will only be run if all dependencies have status COMPLETED. This hash-based approach enables order-independent submission: you can submit an analysis before its dependencies exist, and it will wait in DEPENDENCY status until they complete. If any dependency fails/cancels, this analysis will also fail.

parameters pydantic-field

Parameters to use in the analysis as per the analysis config. Each parameter is a tuple of [name, value] where name is the api_name from the analysis config.

get_analysis_request_hash(include=('analysis_config_id', 'parameters', 'dependencies', 'channels'))

Return a sha1 hash of the JSON str serialized analysis request.

This can be used to compare the analysis submission against other analysis submissions. Note that only the fields specified in the include set are considered when creating the hash. Per default, all fields are included. This flag is useful to ensure consistent outputs of this function if the class is used as a base class for other classes, which may define other fields in the model.

Boolean parameters are stored as Python bool and serialize consistently to JSON as true/false (lowercase), ensuring consistent hashing.

Parameters:

Name Type Description Default
include Sequence[str]

The fields to include in the hash.

 ('analysis_config_id', 'parameters', 'dependencies', 'channels')

Returns:

Type Description
str

The sha1 hash of the analysis and its parameters.

validate_channels(value) pydantic-validator

Validate that all channels are unique.

AnalysisResponse pydantic-model

Bases: AnalysisIdMixin, AnalysisStatusMixin

Internal response that can include logs/events/exit_code.

Fields:

events = None pydantic-field

Result of the analysis if successful. Can be a list of Events, a URL to download, or the literal 'default-storage' indicating backend storage.

exit_code = None pydantic-field

Exit code of the analysis process if it was run

logs = None pydantic-field

Logs of the analysis if it was run.

AnalysisRunOut pydantic-model

Bases: BaseModel

Where an analysis runs or ran, and on what.

The place is known from submission. The image digest and the inputs' SHA-256 come from the runner's attestation once the run's result is accepted; until then, and for a run that predates attestations, they are empty.

Fields:

image_digest = None pydantic-field

The digest of the image that ran.

input_sha256 pydantic-field

The inputs, as the runner read them.

place pydantic-field

On the platform, or at the organisation's own site.

recorded_at = None pydantic-field

When the run's result was accepted.

runner_name = None pydantic-field

The runner that ran it. Shown to the organisation's owners and admins, and to platform administrators; None for anyone else.

AnalysisSelector pydantic-model

Bases: _SelectorBase

Address a set of analyses: exactly one of ids | filter | all.

Fields:

Validators:

  • _exactly_one_mode

filter = None pydantic-field

Server-resolved predicate (live set).

AnalysisSubmission pydantic-model

Bases: AnalysisRequest

Analysis submission information.

Fields:

Validators:

analysis_hours pydantic-field

The number of hours of signal that were processed by the analysis. This is used for cost estimation and setting usage limits.

container_image pydantic-field

The full image name of the container to be used for the analysis including registry, repository, and tag.

docker_volumes pydantic-field

The volumes to be mounted in the docker container. The keys are the host paths or docker volume names and the values are dictionaries with parameters 'bind' and 'mode'.

id pydantic-field

Unique identifier of the analysis

manifest pydantic-field

The document the container receives: inputs by path with their description, the resolved channels, slots, typed parameters, the resource claim and the output path. The container reads this and nothing else.

max_sample_rate_hz = None pydantic-field

Maximum NATIVE sample rate (Hz) across the resolved channel selection. Feeds the per-kHz term of the memory formula (see ResourceRequirements) so recordings sampled above an analysis's working rate are provisioned proportionally more memory. Always populated on submissions built by the current api-server (every ingested channel carries a sample rate — EDF is the only supported format and its parser computes the rate from required header fields). Optional ONLY so that submissions persisted as JSONB before this field existed still validate when re-dispatched after deploy (e.g. an analysis queued on unresolved dependencies); consumers must substitute a conservative assumed rate for None rather than 0, which would silently under-size the claim.

priority = 0 pydantic-field

Priority of the analysis. Higher priority analyses are executed first.

remote_file_mappings pydantic-field

A list of remote file mappings for the analysis submission. The mappings specify how the input and output files should be mapped to/from the local file system of the analysis container.

resolved_resources = None pydantic-field

The resource claim resolved for THIS submission from resource_requirements and the submission's hours, resolved channel count and native sample rate. Resolved once at submission so the container's memory hint and the orchestrator's cgroup ceiling are two renderings of one number rather than two independent derivations. Optional ONLY so that submissions persisted as JSONB before this field existed still validate when re-dispatched after deploy (e.g. an analysis queued on unresolved dependencies); consumers must fall back to deriving the claim from the coefficients for None rather than treating it as a zero claim, which would leave the analysis unbounded.

resource_requirements pydantic-field

The resource requirement COEFFICIENTS for the analysis, snapshotted from the analysis config at submission so a later re-calibration cannot rewrite what an existing analysis ran under. These are rates; resolved_resources holds the quantities they produced for this submission.

AnalysisUsage pydantic-model

Bases: BaseModel

Response model for the analysis usage endpoint.

Fields:

analyses = 0 pydantic-field

The total number of analyses run by the user.

credit_cost = 0.0 pydantic-field

The total cost of the analyses run by the user.

signal_hours = 0.0 pydantic-field

The total number of hours of signal data processed by the user.

AnnotatedAnalysisEvents pydantic-model

Bases: BaseModel

Events with associated analysis metadata for API download.

Fields:

AnnotatedEventStats pydantic-model

Bases: BaseModel

Event statistics with associated analysis metadata.

Fields:

ApiKeyCreate pydantic-model

Bases: BaseModel

Request to create an API key on the signed-in account.

Fields:

Validators:

  • _scopes_are_scopeable

description = None pydantic-field

What the key is for and what holds it, for the account's own records: a device, a system, an integration.

expires_in_days = None pydantic-field

Days until the key expires, at most the server's maximum. Omitted means the server's default lifetime. Every key expires; rotate by creating the next key before this one lapses.

name pydantic-field

A label for telling keys apart, such as the system that will hold it.

password pydantic-field

The account password, entered again: creating a long-lived credential is confirmed by the person, not only by their session.

scopes pydantic-field

The permissions the key may exercise. A key never holds more than its owner holds at the time of a request, and cannot be scoped to account (user:*) or key (api_key:*) management. The server reports which permissions may be delegated (GET /status/permissions, key_scopeable) and refuses any other.

ApiKeyCreated pydantic-model

Bases: ApiKeyOut

The response to creating a key: the listing fields plus the secret.

Fields:

secret pydantic-field

The full key. It appears only in this response; store it in a secret manager now. Send it as Authorization: Bearer <key>.

ApiKeyOut pydantic-model

Bases: BaseModel

An API key as listed on the account: everything except the secret.

Config:

  • from_attributes: True

Fields:

description = None pydantic-field

What the key is for and what holds it.

expired pydantic-field

Whether the key has passed its expiry. An expired key no longer authenticates; delete it and create a new one.

expires_at pydantic-field

When the key stops authenticating requests.

last_used_at = None pydantic-field

When the key last authenticated a request, recorded to the hour; null if it never has.

prefix pydantic-field

The first characters of the key, for telling keys apart in a list or a log. Never enough to use the key.

scopes pydantic-field

The permissions the key was created with.

AuditActionInfo pydantic-model

Bases: BaseModel

One audit action as the server records it.

The vocabulary is served so that a client renders it instead of keeping a copy: an audit view offers as filters exactly the actions its reader can receive, named as the server names them.

Fields:

action pydantic-field

The action, as its events carry it.

item_keys pydantic-field

The detail keys of this action that hold item ids, alone or in a list: the ids an audit view's item filter matches.

name pydantic-field

How the action reads.

readers pydantic-field

Who can ever read an event of this action, besides the platform's administrators: organisation (its owner and admins), project (the project's owner) and subject (the person it is about).

removal pydantic-field

Whether the action records something removed for good: a deletion or a purge.

AuditEventListResponse pydantic-model

Bases: PaginatedResponse

A page of audit events, newest first.

Fields:

export_limit pydantic-field

The most events one CSV export of this view holds. An export of more is refused: narrow the filters until total fits.

AuditEventOut pydantic-model

Bases: BaseModel

One audit event, as recorded.

Config:

  • from_attributes: True

Fields:

Validators:

action pydantic-field

What happened. A plain string, so a newly recorded kind of action needs no client update; the server serves its vocabulary at GET /status/audit-actions.

actor pydantic-field

Who acted: admin:<user id> for an administrator, user:<user id> for an account owner, system:<name> for a scheduled task.

detail pydantic-field

Non-personal context of the action — counts, bytes, dates, the names of fields that changed. Keys vary by action.

id pydantic-field

Identifier of the event; time-ordered.

occurred_at pydantic-field

When the action happened.

org_id = None pydantic-field

The affected organization, when the action concerns one. A bare identifier: the organization may no longer exist.

user_id = None pydantic-field

The affected account, when the action concerns one. A bare identifier: the account may no longer exist.

AuditFilters pydantic-model

Bases: BaseModel

What narrows an audit view: the same filters on every view.

Config:

  • extra: forbid

Fields:

actions = None pydantic-field

Only events recording one of these actions.

resource_id = None pydantic-field

Only events naming this item: a project, study, recording, analysis, export, invitation or API key.

since = None pydantic-field

Only events at or after this time.

until = None pydantic-field

Only events before this time.

user_id = None pydantic-field

Only events concerning this account.

AxisTick pydantic-model

Bases: BaseModel

One axis tick: value, normalized position, display label.

Fields:

clock_label = None pydantic-field

Wall-clock display label (e.g. '23:00') for time axes whose producer knows the recording start. None on non-time axes or producers predating the field; consumers offer an Elapsed/Clock toggle when present.

fraction pydantic-field

Position, 0 (left) … 1 (right).

label pydantic-field

Display label for the tick.

value pydantic-field

Tick value in the domain's unit.

BaseSummaryStats pydantic-model

Bases: BaseModel

Base model for aggregated distribution statistics.

Shared by both event summary stats and biomarker summary stats.

Fields:

analysis_config_id pydantic-field

The ID of the analysis configuration.

analysis_parameters pydantic-field

The analysis parameters used in computation.

origins pydantic-field

Studies/analyses that contributed to these stats. May be empty when origins_ref is set — the referenced shared list on the response envelope is then authoritative (large reports carry each distinct origins list once instead of repeating it per entry).

origins_ref = None pydantic-field

Key into the response envelope's origins_sets when the origins list is shared between entries. None when origins is carried inline.

origins_summary = None pydantic-field

Aggregate provenance. Always derivable from the origins list when one is carried; on very large reports the producer may carry ONLY this summary (origins empty, origins_ref None) to bound the payload — renderers must then read counts, group labels, window sources and research-regime markers from here, and fetch per-study detail from the audit endpoints. None for producers predating the field.

stats pydantic-field

Metric name to distribution statistics.

BatchAnalysesQuote pydantic-model

Bases: BaseModel

Pre-flight cost quote for a batch submission (same body as the submit).

Runs the exact per-step validation/pricing path the submission uses, so a quoted (non-error) step submits at that price. The aggregate mirrors :class:~yousleep_common.models.billing.BillingQuote: each balance the batch uses gets its own line, and blocked_reason applies when any of them cannot cover its part, against the org's current balances. Advisory — the submission's own reserve remains the gate.

Fields:

blocked_reason = None pydantic-field

Why the batch would be rejected (a balance it uses cannot cover its part), or null.

input_coverage pydantic-field

Per step, how many recordings have each declared input.

placement = None pydantic-field

Where the batch's analyses would run. Null from a server that predates it, and when no step was quoted.

studies_without_recordings pydantic-field

Studies the selector addressed that have no recording to analyse; they are not among the results. Empty for explicit targets.

total_estimated_credits pydantic-field

Sum of the quoted steps' credit costs (errored steps excluded).

wallets pydantic-field

What the batch asks of each balance it uses: research analyses of grants, commercial ones of purchased credits.

BatchAnalysisIdsRequest pydantic-model

Bases: BaseModel

Shared base for batch requests that take a list of analysis IDs.

Fields:

  • analysis_ids (list[UUID])

BatchAnalysisPipelineStep pydantic-model

Bases: BaseModel

A single step in a batch analysis pipeline.

Fields:

  • step_id (str | None)
  • analysis_config_id (AnalysisConfigIdStr)
  • default_channels (list[str] | None)
  • parameters (list[tuple[str, str | int | float | bool]])
  • depends_on (list[str])
  • per_recording_overrides (dict[UUID, BatchRecordingOverride] | None)

BatchAnalysisResult pydantic-model

Bases: BaseModel

Result for a single (target, step) pair in a batch analysis response.

Fields:

BatchAnalysisStatusResult pydantic-model

Bases: BaseModel

Result for a single analysis in batch status polling.

Fields:

BatchAnalysisStatusSummary pydantic-model

Bases: _OkErrorSummary

Summary for batch analysis status polling.

Fields:

  • total (int)
  • ok (int)
  • errors (int)

BatchAnalysisSummary pydantic-model

Bases: BatchSummary

Summary for batch analysis submission.

Fields:

  • total (int)
  • submitted (int)
  • errors (int)

BatchAnalysisTarget pydantic-model

Bases: BaseModel

A target recording for batch analysis submission.

Fields:

  • study_id (UUID)
  • recording_id (UUID)

BatchCancelAnalysesRequest pydantic-model

Bases: BatchAnalysisIdsRequest

Request body for batch analysis cancellation.

Fields:

  • analysis_ids (list[UUID])

BatchCancelAnalysesResponse pydantic-model

Bases: BaseModel

Response for batch analysis cancellation.

Fields:

BatchCancelResult pydantic-model

Bases: BaseModel

Result for a single analysis cancellation.

Fields:

  • analysis_id (UUID)
  • status (Literal['cancelled', 'error'])
  • error (BatchItemError | None)

BatchCancelSummary pydantic-model

Bases: BatchSummary

Summary for batch analysis cancellation.

Fields:

  • total (int)
  • cancelled (int)
  • errors (int)

BatchChannelPatchSummary pydantic-model

Bases: BatchSummary

Summary for the bulk channel patch (total = number of patches submitted).

Fields:

  • total (int)
  • updated (int)
  • errors (int)
  • channels_updated (int)

BatchCreateStudiesRequest pydantic-model

Bases: BaseModel

Request body for batch study creation.

Fields:

BatchCreateStudiesResponse pydantic-model

Bases: BaseModel

Response for batch study creation.

Fields:

BatchDeleteAccepted pydantic-model

Bases: BaseModel

The delete resolved and was enqueued (fire-and-return).

Deletion runs as a background cascade; list endpoints hide the affected rows for the run's duration. The ids were resolved at acceptance — rows created after this response are not part of the run.

Fields:

count pydantic-field

Rows resolved and scheduled for deletion.

BatchEventBlocksResult pydantic-model

Bases: BaseModel

Result for a single analysis in batch event-block retrieval.

Fields:

count = None pydantic-field

Events the document decodes to — the sum of every block's slot count.

BatchEventResult pydantic-model

Bases: BaseModel

Result for a single analysis in batch event retrieval.

Fields:

  • analysis_id (UUID)
  • status (Literal['ok', 'error'])
  • events (list[Event] | None)
  • count (int | None)
  • error (BatchItemError | None)

BatchEventSummary pydantic-model

Bases: _OkErrorSummary

Summary for batch event retrieval.

Fields:

  • total (int)
  • ok (int)
  • errors (int)

BatchGetAnalysesStatusRequest pydantic-model

Bases: BatchAnalysisIdsRequest

Request body for batch analysis status polling.

Fields:

  • analysis_ids (list[UUID])

BatchGetAnalysesStatusResponse pydantic-model

Bases: BaseModel

Response for batch analysis status polling.

Fields:

BatchGetEventBlocksRequest pydantic-model

Bases: BatchAnalysisIdsRequest

Request body for batch event-block retrieval.

Deliberately carries no filter. The single-analysis block endpoint has none either — a block document is meant to be fetched once and sliced locally — and giving the batch form a filter the per-analysis form lacks would make the two disagree about what a block document is.

Fields:

analysis_ids pydantic-field

Analyses to fetch blocks for — at most the schema's maxItems per request, which is the cap the server enforces (GET /status/limits reports the same number).

BatchGetEventBlocksResponse pydantic-model

Bases: BaseModel

Response for batch event-block retrieval.

Fields:

BatchGetEventsRequest pydantic-model

Bases: BatchAnalysisIdsRequest

Request body for batch event retrieval.

Fields:

BatchGetEventsResponse pydantic-model

Bases: BaseModel

Response for batch event retrieval.

Fields:

BatchGetRecordingsByStudiesRequest pydantic-model

Bases: BaseModel

Request body for fetching the recordings of multiple studies in one call.

Fields:

  • study_ids (list[UUID])

BatchGetRecordingsByStudiesResponse pydantic-model

Bases: BaseModel

Response for batch recordings-by-study retrieval (keyed by study id).

Fields:

BatchGetRecordingsDetailsRequest pydantic-model

Bases: BaseModel

Request body for batch recording details retrieval.

Fields:

  • recording_ids (list[UUID])

BatchGetRecordingsDetailsResponse pydantic-model

Bases: BaseModel

Response for batch recording details retrieval.

Fields:

BatchGetStudiesByIdsRequest pydantic-model

Bases: BaseModel

Request body for fetching multiple studies by id in one call.

Fields:

  • study_ids (list[UUID])

BatchGetStudiesByIdsResponse pydantic-model

Bases: BaseModel

Response for batch study by-id retrieval (keyed by study id).

Fields:

BatchItemError pydantic-model

Bases: BaseModel

Per-item error in a batch response.

Fields:

code pydantic-field

Stable machine-readable error code for this item; branch on this, not on the message text.

BatchPatchChannelsRequest pydantic-model

Bases: BaseModel

Request body for the bulk channel patch.

Fields:

BatchPatchChannelsResponse pydantic-model

Bases: BaseModel

Response for the bulk channel patch.

Fields:

BatchPatchStudiesMetadataRequest pydantic-model

Bases: BaseModel

Apply metadata patches across many studies (207 per-item results).

Fields:

BatchPatchStudiesMetadataResponse pydantic-model

Bases: BaseModel

Per-item results plus the usual batch summary.

Fields:

BatchQuoteResult pydantic-model

Bases: BaseModel

Quoted cost (or error) for a single (target, step) pair.

Fields:

channels = None pydantic-field

The recording's channels this run receives, by name, in the order the analysis gets them: the platform's match (the first ones in montage order where the recording has more than the analysis takes) or the channels chosen explicitly. Null on a refused result.

missing_inputs = None pydantic-field

The declared inputs this recording lacks, by name (a channel type, an exact channel, or a subject value); empty when it has every one. Null when the step was not resolved against the recording.

BatchQuoteSummary pydantic-model

Bases: BatchSummary

Summary for a batch analysis quote.

Fields:

  • total (int)
  • quoted (int)
  • errors (int)

BatchRecordingDetailResult pydantic-model

Bases: BaseModel

Result for a single recording in batch details retrieval.

Fields:

BatchRecordingDetailSummary pydantic-model

Bases: _OkErrorSummary

Summary for batch recording details retrieval.

Fields:

  • total (int)
  • ok (int)
  • errors (int)

BatchRecordingOverride pydantic-model

Bases: BaseModel

Per-recording overrides for a pipeline step.

Fields:

  • channels (list[str] | None)

BatchRecordingsByStudyResult pydantic-model

Bases: BaseModel

Result for a single study in batch recordings-by-study retrieval.

Fields:

BatchRecordingsByStudySummary pydantic-model

Bases: _OkErrorSummary

Summary for batch recordings-by-study retrieval.

Fields:

  • total (int)
  • ok (int)
  • errors (int)

BatchSetStudyLightsRequest pydantic-model

Bases: BaseModel

Assign lights markers across many studies (207 per-item results).

Fields:

replace_existing = False pydantic-field

False: rows whose targeted marker already exists error per-item (manual edits win by default). True: overwrite.

BatchSetStudyLightsResponse pydantic-model

Bases: BaseModel

Per-item results plus the usual batch summary.

Fields:

BatchStudyByIdResult pydantic-model

Bases: BaseModel

Result for a single study in batch by-id retrieval.

Fields:

BatchStudyByIdSummary pydantic-model

Bases: _OkErrorSummary

Summary for batch study by-id retrieval.

Fields:

  • total (int)
  • ok (int)
  • errors (int)

BatchStudyItem pydantic-model

Bases: BaseModel

A single study to create in a batch.

Fields:

session_index = None pydantic-field

Declared position of this study in its subject's series, 1 = first. Same contract as StudyMetadata.session_index.

subject_key = None pydantic-field

The person this study belongs to, so a night is filed under its subject at creation rather than patched in afterwards. Same contract as StudyMetadata.subject_key.

BatchStudyMetadataSummary pydantic-model

Bases: BatchSummary

Summary for a metadata/lights batch.

Fields:

  • total (int)
  • updated (int)
  • errors (int)

BatchStudyResult pydantic-model

Bases: BaseModel

Result for a single study in a batch response.

Fields:

BatchStudySummary pydantic-model

Bases: BatchSummary

Summary for batch study creation.

Fields:

  • total (int)
  • created (int)
  • errors (int)

BatchSubmitAnalysesRequest pydantic-model

Bases: BaseModel

Request body for batch analysis submission (and its quote).

Targets are addressed either explicitly (targets) or through a study selector (the batch addressing language): the server resolves the matched studies to their recordings at acceptance time. Exactly one of the two must be set. Live-set selectors (filter/all) must state expected_count — the matched-STUDY total the caller last resolved (the filtered study list's total); the server re-resolves and rejects on a mismatch. A selector that resolves to more recordings than an explicit request may carry is rejected with the resolved count — narrow the filter and submit in slices.

Fields:

Validators:

  • _one_addressing_mode

complete_inputs_only = False pydantic-field

Leave out recordings that lack an optional input the analysis declares, so every run receives the same inputs. A recording lacking a required input is refused either way.

expected_count = None pydantic-field

Required for filter/all selectors: the matched-study count the caller saw. The server re-resolves and rejects on a mismatch.

selector = None pydantic-field

Address targets as a study set; the server resolves each matched study's recordings.

BatchSubmitAnalysesResponse pydantic-model

Bases: BaseModel

Response for batch analysis submission.

Fields:

studies_without_recordings pydantic-field

Studies the selector addressed that have no recording to analyse; nothing was submitted for them. Empty for explicit targets.

BatchSummary pydantic-model

Bases: BaseModel

Base summary counts for batch responses. Subclassed per-endpoint.

Fields:

  • total (int)

BillingQuote pydantic-model

Bases: WalletQuote

Pre-flight cost quote for one analysis: the balance it is paid from, and whether it covers it.

Fields:

placement = None pydantic-field

Where the analysis would run. Null from a server that predates it.

BillingRates pydantic-model

Bases: BaseModel

Public billing rates and grant terms (config-fixed platform pricing).

Served by GET /status/billing-rates so clients display the SAME numbers the server charges and grants with, instead of hardcoding them. Credits are the unit throughout; euro pricing lives in the Stripe checkout.

Config:

  • frozen: True

Fields:

credit_cost_per_signal_hour pydantic-field

Credits charged per hour of analysed signal, unless an analysis sets its own price.

default_grant_term_months pydantic-field

The term a request starts at.

grant_buffer_pct pydantic-field

The margin a grant request adds to its plan's computed cost by default, in percent.

grant_expiry_banner_days pydantic-field

Days before a grant expires from which the organization's page shows the coming expiry.

grant_terms_months pydantic-field

The terms, in months, a grant or an extension may be asked for.

minimum_credits_per_analysis pydantic-field

Minimum credits charged per analysis submission.

starter_grant_credits pydantic-field

Research credits every new organization receives once; they never expire.

storage_credits_per_gb_month pydantic-field

Purchased credits charged per GB per month stored above an organization's free ceiling (daily debit). Storage up to the ceiling is free.

storage_grace_days pydantic-field

Days of grace after paid storage can no longer be paid for before the recordings above the ceiling are deleted.

BiomarkerParameters pydantic-model

Bases: BaseModel

Parameters for biomarker computation.

TIB window is not included here — it comes from StatisticsWindow, resolved from study events or client override in the report use case.

Fields:

epoch_duration_sec = 30 pydantic-field

Epoch duration in seconds

soremp_threshold_min = 15.0 pydantic-field

Maximum minutes from sleep onset to the first REM epoch for the night to count a SOREMP

BiomarkerResult pydantic-model

Bases: BaseModel

Complete biomarker computation result for a single analysis.

Fields:

biomarkers pydantic-field

13 standard sleep biomarkers

metadata pydantic-field

Computation metadata (epoch count, computation time, etc.)

qc pydantic-field

Quality metrics

BiomarkerSummaryStats pydantic-model

Bases: BaseSummaryStats

Aggregated biomarker statistics across multiple analyses.

Inherits from BaseSummaryStats — same stats dict pattern as SummaryStats but without event-specific fields.

Fields:

Biomarkers pydantic-model

Bases: BaseModel

13 standard sleep biomarkers.

TST, TIB, SE, SOL and WASO, plus REM latency, SOREMPs, the stage percentages and the sleep fragmentation index. The definitions follow the AASM scoring manual except where a description says otherwise. Each description is the metric's definition as the platform computes it, gotchas included, and is served as its help text. A metric that is undefined for a night (no sleep, no REM) is empty (None), never 0.

Sleep means an epoch scored N1, N2, N3 or REM (R&K stages 1-4 map onto them). "Sleep stage ?" (unscored), the generic "Sleep stage N" and movement time are no stage: they count toward time in bed and nothing else.

Fields:

fragmentation_index = None pydantic-field

Sleep fragmentation index: awakenings (sleep followed by wake) plus shifts to a lighter sleep stage (N3 to N2 or N1, N2 to N1, REM to N1), per hour of total sleep time. Counted between consecutive scored epochs; unscored epochs are skipped. It depends on the epoch length: shorter epochs resolve brief changes that 30-second scoring averages away, so compare it only between analyses with the same epoch length. Empty when no sleep is scored.

rem_latency_min = None pydantic-field

REM latency: minutes from sleep onset to the first REM epoch, wake in between included. Some software measures it from lights off or the start of the recording instead, which adds the sleep onset latency. Empty when no REM is scored.

sleep_efficiency_pct pydantic-field

Sleep efficiency: total sleep time as a percentage of time in bed (TST / TIB x 100). Without lights markers TIB is the whole recording, so efficiency reads lower than a lights-off-to-on figure.

sleep_onset_latency_min pydantic-field

Sleep onset latency: minutes from the start of the statistics window to the first epoch scored N1, N2, N3 or REM. When no sleep is scored it equals time in bed: the night counts as never falling asleep, and enters group means at that value.

soremps_count pydantic-field

Sleep-onset REM period: 1 when the first REM epoch begins within the SOREMP threshold (15 minutes by default) of sleep onset, otherwise 0. A per-night indicator for a nocturnal recording, not an MSLT's count across naps; summed over nights it is the number of nights with a SOREMP.

stage_percentages pydantic-field

Stage percentages

tib_min pydantic-field

Time in bed: the length of the statistics window in minutes, lights off to lights on when the study records them, otherwise the whole recording (the AASM's total recording time). Without lights markers it includes time before lights off and after lights on, which lowers sleep efficiency and lengthens sleep onset latency.

tst_min pydantic-field

Total sleep time: minutes scored N1, N2, N3 or REM inside the statistics window. Unscored epochs, the generic 'Sleep stage N' and movement time count toward no stage.

waso_min = None pydantic-field

Wake after sleep onset: minutes of wake between the first and the last epoch scored as sleep. Wake after the final awakening is not included; the AASM definition (TRT - sleep latency - TST) also counts wake until lights on, so it reads higher when the morning wake period is long. Empty when no sleep is scored.

BoxplotBoxValues pydantic-model

Bases: BaseModel

Five-number summary — raw values or normalized fractions.

Fields:

  • min (float)
  • q1 (float)
  • median (float)
  • q3 (float)
  • max (float)

BoxplotModel pydantic-model

Bases: BaseModel

A horizontal box-and-whisker chart: shared axis + rows.

Fields:

decimals = 1 pydantic-field

Decimal places for 'decimal' formatting; ignored otherwise. Matches the tick precision the producer chose.

domain_max pydantic-field

Axis maximum, in the axis unit.

domain_min pydantic-field

Axis minimum, in the axis unit.

rows pydantic-field

The rows, in display order.

svg = None pydantic-field

Server-rendered inline SVG of this chart: the one renderer behind live pages and document exports. Colors are CSS custom-property references the page resolves; elements carry stable classes, native tooltips and data-* attributes so consumers can layer interaction without geometry knowledge. None for producers predating the field — consumers fall back to drawing the geometry themselves.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotModel.ticks" class="doc doc-heading"> <code class="highlight language-python"><span class="n">ticks</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotModel.ticks" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Axis ticks at nice intervals.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotModel.unit_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit_label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotModel.unit_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Axis caption including the unit, e.g. 'Total duration (h)'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotModel.value_format" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value_format</span> <span class="o">=</span> <span class="s1">'decimal'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotModel.value_format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How a consumer renders one of this chart's VALUES as text (tooltips, data labels). The axis ticks are already formatted in <code>ticks[].label</code>; this is the same rule for the numbers between them, so a tooltip cannot contradict the axis above it. 'duration-hours' means values are hours to be shown as a duration ('1h 30m'); 'decimal' means a plain number at <code>decimals</code> places. Defaults to 'decimal' so a producer predating the field is read literally rather than as hours.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.BoxplotPoint" class="doc doc-heading"> <code>BoxplotPoint</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.BoxplotPoint" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One raw observation drawn as a dot, in the axis unit and on the 0…1 domain.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="value pydantic-field (yousleep_common.models.charts.BoxplotPoint.value)" href="charts/#yousleep_common.models.charts.BoxplotPoint.value">value</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="fraction pydantic-field (yousleep_common.models.charts.BoxplotPoint.fraction)" href="charts/#yousleep_common.models.charts.BoxplotPoint.fraction">fraction</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label = None pydantic-field (yousleep_common.models.charts.BoxplotPoint.label)" href="charts/#yousleep_common.models.charts.BoxplotPoint.label">label</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotPoint.fraction" class="doc doc-heading"> <code class="highlight language-python"><span class="n">fraction</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotPoint.fraction" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The same value on the shared domain.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotPoint.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotPoint.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Which observation the dot is, for its tooltip — the study, and the subject and visit it belongs to when those are declared. None when the source draws anonymous observations.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotPoint.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotPoint.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The observation, in the axis unit.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.BoxplotRow" class="doc doc-heading"> <code>BoxplotRow</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.BoxplotRow" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One labelled box-and-whisker row on a shared axis.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.charts.BoxplotRow.label)" href="charts/#yousleep_common.models.charts.BoxplotRow.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="values pydantic-field (yousleep_common.models.charts.BoxplotRow.values)" href="charts/#yousleep_common.models.charts.BoxplotRow.values">values</a></code> (<code><a class="autorefs autorefs-internal" title="BoxplotBoxValues pydantic-model (yousleep_common.models.charts.BoxplotBoxValues)" href="charts/#yousleep_common.models.charts.BoxplotBoxValues">BoxplotBoxValues</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="fractions pydantic-field (yousleep_common.models.charts.BoxplotRow.fractions)" href="charts/#yousleep_common.models.charts.BoxplotRow.fractions">fractions</a></code> (<code><a class="autorefs autorefs-internal" title="BoxplotBoxValues pydantic-model (yousleep_common.models.charts.BoxplotBoxValues)" href="charts/#yousleep_common.models.charts.BoxplotBoxValues">BoxplotBoxValues</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="n = None pydantic-field (yousleep_common.models.charts.BoxplotRow.n)" href="charts/#yousleep_common.models.charts.BoxplotRow.n">n</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subjects = None pydantic-field (yousleep_common.models.charts.BoxplotRow.subjects)" href="charts/#yousleep_common.models.charts.BoxplotRow.subjects">subjects</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="color_token = None pydantic-field (yousleep_common.models.charts.BoxplotRow.color_token)" href="charts/#yousleep_common.models.charts.BoxplotRow.color_token">color_token</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="series_key = None pydantic-field (yousleep_common.models.charts.BoxplotRow.series_key)" href="charts/#yousleep_common.models.charts.BoxplotRow.series_key">series_key</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="points = None pydantic-field (yousleep_common.models.charts.BoxplotRow.points)" href="charts/#yousleep_common.models.charts.BoxplotRow.points">points</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="BoxplotPoint pydantic-model (yousleep_common.models.charts.BoxplotPoint)" href="charts/#yousleep_common.models.charts.BoxplotPoint">BoxplotPoint</a>] | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_fractions_bounded() pydantic-validator (yousleep_common.models.charts.BoxplotRow.validate_fractions_bounded)" href="charts/#yousleep_common.models.charts.BoxplotRow.validate_fractions_bounded">validate_fractions_bounded</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.color_token" class="doc doc-heading"> <code class="highlight language-python"><span class="n">color_token</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.color_token" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Brand color token NAME (e.g. 'primary-600'); consumers resolve it (CSS variable live, tokens.yaml literal in PDFs).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.fractions" class="doc doc-heading"> <code class="highlight language-python"><span class="n">fractions</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.fractions" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The same box mapped to 0…1 on the shared domain.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Row label (e.g. an event type).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.n" class="doc doc-heading"> <code class="highlight language-python"><span class="n">n</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.n" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Sample count behind the box.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.points" class="doc doc-heading"> <code class="highlight language-python"><span class="n">points</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.points" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set when the row has too few observations for a box to mean anything (below the producer's configured minimum): the raw observations, drawn as dots on the shared axis instead of the box. <code>values</code>/<code>fractions</code> still carry the five-number summary of the same observations, so a consumer that ignores this field draws a (degenerate) box rather than nothing.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.series_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">series_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.series_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable series identifier stamped as a CSS class hook (e.g. group show/hide).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.subjects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subjects</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.subjects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Distinct subjects behind the same observations, when the producer knows them and they can differ from <code>n</code> — one person recorded twice in a calendar bin is two observations and one subject. None when subjects are unknown or not meaningful for the row.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.BoxplotRow.values" class="doc doc-heading"> <code class="highlight language-python"><span class="n">values</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.values" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Raw five-number summary, in the axis unit (tooltips/data-*).</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.BoxplotRow.validate_fractions_bounded" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_fractions_bounded</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.BoxplotRow.validate_fractions_bounded" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Fractions must lie on the shared 0…1 domain.</p> <p><code>values</code> and <code>fractions</code> share a shape but not an invariant — the bound lives here so a producer whose domain math drifts fails at the contract, not in a renderer.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CapabilityRequestCreate" class="doc doc-heading"> <code>CapabilityRequestCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An owner's request for a capability.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestCreate.capability">capability</span></code> (<code><a class="autorefs autorefs-internal" title="SiteCapability (yousleep_common.types.sites.SiteCapability)" href="../types/sites/#yousleep_common.types.sites.SiteCapability">SiteCapability</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="note = '' pydantic-field (yousleep_common.models.site_capabilities.CapabilityRequestCreate.note)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityRequestCreate.note">note</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CapabilityRequestCreate.note" class="doc doc-heading"> <code class="highlight language-python"><span class="n">note</span> <span class="o">=</span> <span class="s1">''</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestCreate.note" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the organisation wants to use it for, for the administrators.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CapabilityRequestDecision" class="doc doc-heading"> <code>CapabilityRequestDecision</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestDecision" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An administrator's decision on a request.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestDecision.decision">decision</span></code> (<code><span title="typing.Literal">Literal</span>['approved', 'declined']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason = None pydantic-field (yousleep_common.models.site_capabilities.CapabilityRequestDecision.reason)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityRequestDecision.reason">reason</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestDecision.decided_at">decided_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CapabilityRequestDecision.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestDecision.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why the request was declined; None for an approval.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CapabilityRequestOut" class="doc doc-heading"> <code>CapabilityRequestOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A request for a capability, with its decision once made.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.id">id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.org_id">org_id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.capability">capability</span></code> (<code><a class="autorefs autorefs-internal" title="SiteCapability (yousleep_common.types.sites.SiteCapability)" href="../types/sites/#yousleep_common.types.sites.SiteCapability">SiteCapability</a></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.status">status</span></code> (<code><a class="autorefs autorefs-internal" title="CapabilityRequestStatus (yousleep_common.types.sites.CapabilityRequestStatus)" href="../types/sites/#yousleep_common.types.sites.CapabilityRequestStatus">CapabilityRequestStatus</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="requested_by = None pydantic-field (yousleep_common.models.site_capabilities.CapabilityRequestOut.requested_by)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityRequestOut.requested_by">requested_by</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.requested_by_name">requested_by_name</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="note pydantic-field (yousleep_common.models.site_capabilities.CapabilityRequestOut.note)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityRequestOut.note">note</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.created_at">created_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestOut.decision">decision</span></code> (<code><a class="autorefs autorefs-internal" title="CapabilityRequestDecision pydantic-model (yousleep_common.models.site_capabilities.CapabilityRequestDecision)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityRequestDecision">CapabilityRequestDecision</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CapabilityRequestOut.note" class="doc doc-heading"> <code class="highlight language-python"><span class="n">note</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestOut.note" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the organisation wants to use it for.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CapabilityRequestOut.requested_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">requested_by</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestOut.requested_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Who asked; None once that account is gone.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CapabilityRequestPage" class="doc doc-heading"> <code>CapabilityRequestPage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CapabilityRequestPage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A page of an organisation's requests for capabilities, newest first.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestPage.requests">requests</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CapabilityRequestOut pydantic-model (yousleep_common.models.site_capabilities.CapabilityRequestOut)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityRequestOut">CapabilityRequestOut</a>]</code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityRequestPage.total">total</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CapabilityStatus" class="doc doc-heading"> <code>CapabilityStatus</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CapabilityStatus" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Where an organisation stands with one capability.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityStatus.capability">capability</span></code> (<code><a class="autorefs autorefs-internal" title="SiteCapability (yousleep_common.types.sites.SiteCapability)" href="../types/sites/#yousleep_common.types.sites.SiteCapability">SiteCapability</a></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.CapabilityStatus.state">state</span></code> (<code><a class="autorefs autorefs-internal" title="CapabilityState (yousleep_common.types.sites.CapabilityState)" href="../types/sites/#yousleep_common.types.sites.CapabilityState">CapabilityState</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="changed_at = None pydantic-field (yousleep_common.models.site_capabilities.CapabilityStatus.changed_at)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityStatus.changed_at">changed_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="request_id = None pydantic-field (yousleep_common.models.site_capabilities.CapabilityStatus.request_id)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityStatus.request_id">request_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CapabilityStatus.changed_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">changed_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CapabilityStatus.changed_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When an administrator last turned it on or off; None if never.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CapabilityStatus.request_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">request_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CapabilityStatus.request_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The request awaiting a decision, while the state is 'requested'.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChangePasswordRequest" class="doc doc-heading"> <code>ChangePasswordRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChangePasswordRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request for an authenticated user to change their own password.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="current_password pydantic-field (yousleep_common.models.authentication.ChangePasswordRequest.current_password)" href="authentication/#yousleep_common.models.authentication.ChangePasswordRequest.current_password">current_password</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="new_password pydantic-field (yousleep_common.models.authentication.ChangePasswordRequest.new_password)" href="authentication/#yousleep_common.models.authentication.ChangePasswordRequest.new_password">new_password</a></code> (<code><a class="autorefs autorefs-internal" title="NewPasswordStr = Annotated[str, Field(min_length=8, max_length=72), AfterValidator(_fits_bcrypt_limit)] module-attribute (yousleep_common.fields.NewPasswordStr)" href="../fields/#yousleep_common.fields.NewPasswordStr">NewPasswordStr</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChangePasswordRequest.current_password" class="doc doc-heading"> <code class="highlight language-python"><span class="n">current_password</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChangePasswordRequest.current_password" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's current password, for verification.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChangePasswordRequest.new_password" class="doc doc-heading"> <code class="highlight language-python"><span class="n">new_password</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChangePasswordRequest.new_password" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The new password (at most 72 bytes — bcrypt's limit). Complexity is enforced by the backend.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelIdentityPatch" class="doc doc-heading"> <code>ChannelIdentityPatch</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelIdentityPatch" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A person's correction of what a channel is.</p> <p>Send a field to set it; send it as null to clear it; leave it out to keep it. Anything set here is recorded as coming from a person and is never overwritten by re-reading the label.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="laterality = None pydantic-field (yousleep_common.models.channel.ChannelIdentityPatch.laterality)" href="channel/#yousleep_common.models.channel.ChannelIdentityPatch.laterality">laterality</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelLaterality = Literal['left', 'right'] module-attribute (yousleep_common.types.channels.ChannelLaterality)" href="../types/channels/#yousleep_common.types.channels.ChannelLaterality">ChannelLaterality</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="canonical_name = None pydantic-field (yousleep_common.models.channel.ChannelIdentityPatch.canonical_name)" href="channel/#yousleep_common.models.channel.ChannelIdentityPatch.canonical_name">canonical_name</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.channel.ChannelIdentityPatch._says_something">_says_something</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelIdentityPatch.canonical_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">canonical_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelIdentityPatch.canonical_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The channel's canonical name ('C3-M2', 'E1'); null clears it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelIdentityPatch.laterality" class="doc doc-heading"> <code class="highlight language-python"><span class="n">laterality</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelIdentityPatch.laterality" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The body side the channel records; null clears it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelIdentitySummary" class="doc doc-heading"> <code>ChannelIdentitySummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelIdentitySummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What the channels behind one vocabulary entry are, across their recordings.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="canonical_names pydantic-field (yousleep_common.models.reports.ChannelIdentitySummary.canonical_names)" href="reports/#yousleep_common.models.reports.ChannelIdentitySummary.canonical_names">canonical_names</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lateralities pydantic-field (yousleep_common.models.reports.ChannelIdentitySummary.lateralities)" href="reports/#yousleep_common.models.reports.ChannelIdentitySummary.lateralities">lateralities</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelLaterality = Literal['left', 'right'] module-attribute (yousleep_common.types.channels.ChannelLaterality)" href="../types/channels/#yousleep_common.types.channels.ChannelLaterality">ChannelLaterality</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="corrected = 0 pydantic-field (yousleep_common.models.reports.ChannelIdentitySummary.corrected)" href="reports/#yousleep_common.models.reports.ChannelIdentitySummary.corrected">corrected</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelIdentitySummary.canonical_names" class="doc doc-heading"> <code class="highlight language-python"><span class="n">canonical_names</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelIdentitySummary.canonical_names" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Distinct canonical names ('C3-M2', 'E1') the entry's channels carry, in first-seen order; empty when none is known.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelIdentitySummary.corrected" class="doc doc-heading"> <code class="highlight language-python"><span class="n">corrected</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelIdentitySummary.corrected" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many of the entry's channels carry an identity a person set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelIdentitySummary.lateralities" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lateralities</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelIdentitySummary.lateralities" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Distinct sides the entry's channels record, in first-seen order; empty when unknown.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelLocation" class="doc doc-heading"> <code>ChannelLocation</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelLocation" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Location of a channel within a recording.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="channel_index pydantic-field (yousleep_common.models.reports.ChannelLocation.channel_index)" href="reports/#yousleep_common.models.reports.ChannelLocation.channel_index">channel_index</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_id pydantic-field (yousleep_common.models.reports.ChannelLocation.study_id)" href="reports/#yousleep_common.models.reports.ChannelLocation.study_id">study_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_id pydantic-field (yousleep_common.models.reports.ChannelLocation.recording_id)" href="reports/#yousleep_common.models.reports.ChannelLocation.recording_id">recording_id</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelLocation.channel_index" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channel_index</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelLocation.channel_index" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Index of the channel in the recording</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelLocation.recording_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelLocation.recording_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recording identifier</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelLocation.study_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelLocation.study_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Study identifier</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelOut" class="doc doc-heading"> <code>ChannelOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="ChannelUpdate pydantic-model (yousleep_common.models.channel.ChannelUpdate)" href="channel/#yousleep_common.models.channel.ChannelUpdate">ChannelUpdate</a></code></p> <p>Represents a single channel in a recording.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.channel.ChannelOut.name">name</span></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a></code>) </li> <li> <code><span title="yousleep_common.models.channel.ChannelOut.type">type</span></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sample_rate = None pydantic-field (yousleep_common.models.channel.ChannelOut.sample_rate)" href="#yousleep_common.models.ChannelUpdate.sample_rate">sample_rate</a></code> (<code><span title="pydantic.types.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.channel.ChannelOut.unit)" href="#yousleep_common.models.ChannelUpdate.unit">unit</a></code> (<code><a class="autorefs autorefs-internal" title="PhysicalDimension (yousleep_common.types.PhysicalDimension)" href="../types/#yousleep_common.types.PhysicalDimension">PhysicalDimension</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="index pydantic-field (yousleep_common.models.channel.ChannelOut.index)" href="channel/#yousleep_common.models.channel.ChannelOut.index">index</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="source_name = None pydantic-field (yousleep_common.models.channel.ChannelOut.source_name)" href="channel/#yousleep_common.models.channel.ChannelOut.source_name">source_name</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="canonical_name = None pydantic-field (yousleep_common.models.channel.ChannelOut.canonical_name)" href="channel/#yousleep_common.models.channel.ChannelOut.canonical_name">canonical_name</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="electrode = None pydantic-field (yousleep_common.models.channel.ChannelOut.electrode)" href="channel/#yousleep_common.models.channel.ChannelOut.electrode">electrode</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reference = None pydantic-field (yousleep_common.models.channel.ChannelOut.reference)" href="channel/#yousleep_common.models.channel.ChannelOut.reference">reference</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="laterality = None pydantic-field (yousleep_common.models.channel.ChannelOut.laterality)" href="channel/#yousleep_common.models.channel.ChannelOut.laterality">laterality</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelLaterality = Literal['left', 'right'] module-attribute (yousleep_common.types.channels.ChannelLaterality)" href="../types/channels/#yousleep_common.types.channels.ChannelLaterality">ChannelLaterality</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="identity_source = None pydantic-field (yousleep_common.models.channel.ChannelOut.identity_source)" href="channel/#yousleep_common.models.channel.ChannelOut.identity_source">identity_source</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelIdentitySource = Literal['label', 'user'] module-attribute (yousleep_common.types.channels.ChannelIdentitySource)" href="../types/channels/#yousleep_common.types.channels.ChannelIdentitySource">ChannelIdentitySource</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.canonical_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">canonical_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.canonical_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>One spelling for one thing: the electrode and its reference as 'C3-M2', 'E1', 'Fpz-Cz'. Read from the label (C3-A2, C3M2 and EEG C3-M2 all give C3-M2) or set by a person. None when the label names no site.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.electrode" class="doc doc-heading"> <code class="highlight language-python"><span class="n">electrode</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.electrode" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The active site in canonical spelling ('C3', 'E1'); None when unknown.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.identity_source" class="doc doc-heading"> <code class="highlight language-python"><span class="n">identity_source</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.identity_source" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where canonical_name and laterality came from: 'label' (read from the file's label) or 'user' (set by a person, never overwritten by re-reading the label). None on channels registered before identity existed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.index" class="doc doc-heading"> <code class="highlight language-python"><span class="n">index</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.index" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The index of the channel in the recording. Must be a positive integer.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.laterality" class="doc doc-heading"> <code class="highlight language-python"><span class="n">laterality</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.laterality" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The body side the channel records, from the electrode (odd 10-20 sites and E1 are left, even sites and E2 right) or set by a person. None when the label does not say, or says two things.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.reference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reference</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.reference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The reference site in canonical spelling ('M2', 'Cz'); None when unreferenced or unknown.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelOut.source_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">source_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelOut.source_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The channel's label as it appears in the source file (EDF) header. Immutable: renaming a channel changes <code>name</code> (the display name) but never this. Analysis containers load signals from the file by this label, so it is what dispatch passes them. None only for channels registered before the field existed.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ChannelOut.__hash__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__hash__</span><span class="p">()</span></code> <a href="#yousleep_common.models.ChannelOut.__hash__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Hash by JSON serialisation (:func:<code>_json_hash</code>).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelPatch" class="doc doc-heading"> <code>ChannelPatch</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelPatch" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A single bulk channel edit.</p> <p>Matches every channel named <code>match_name</code> across the project's recordings and applies the provided fields; unset fields are left unchanged. At least one of <code>new_name</code> / <code>type</code> / <code>unit</code> must be set.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="match_name pydantic-field (yousleep_common.models.batch.ChannelPatch.match_name)" href="batch/#yousleep_common.models.batch.ChannelPatch.match_name">match_name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="new_name = None pydantic-field (yousleep_common.models.batch.ChannelPatch.new_name)" href="batch/#yousleep_common.models.batch.ChannelPatch.new_name">new_name</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type = None pydantic-field (yousleep_common.models.batch.ChannelPatch.type)" href="batch/#yousleep_common.models.batch.ChannelPatch.type">type</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.batch.ChannelPatch.unit)" href="batch/#yousleep_common.models.batch.ChannelPatch.unit">unit</a></code> (<code><a class="autorefs autorefs-internal" title="PhysicalDimension (yousleep_common.types.PhysicalDimension)" href="../types/#yousleep_common.types.PhysicalDimension">PhysicalDimension</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="laterality = None pydantic-field (yousleep_common.models.batch.ChannelPatch.laterality)" href="batch/#yousleep_common.models.batch.ChannelPatch.laterality">laterality</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelLaterality = Literal['left', 'right'] module-attribute (yousleep_common.types.channels.ChannelLaterality)" href="../types/channels/#yousleep_common.types.channels.ChannelLaterality">ChannelLaterality</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="canonical_name = None pydantic-field (yousleep_common.models.batch.ChannelPatch.canonical_name)" href="batch/#yousleep_common.models.batch.ChannelPatch.canonical_name">canonical_name</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.batch.ChannelPatch._require_a_change">_require_a_change</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelPatch.canonical_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">canonical_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelPatch.canonical_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The canonical name ('C3-M2', 'E1') of these channels, if setting it; send null to clear. Recorded as set by a person.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelPatch.laterality" class="doc doc-heading"> <code class="highlight language-python"><span class="n">laterality</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelPatch.laterality" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The body side these channels record, if setting it; send null to clear. Recorded as set by a person.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelPatch.match_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">match_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelPatch.match_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Current channel name to match across recordings.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelPatch.new_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">new_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelPatch.new_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>New channel name (rename), if changing. At most 16 characters, the EDF label length and the limit every channel read enforces — a longer name would be stored and then fail validation on every read of the recording's channels, so it is rejected here.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelPatch.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelPatch.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>New channel type, if changing.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelPatch.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelPatch.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>New physical unit, if changing.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelPatchResult" class="doc doc-heading"> <code>ChannelPatchResult</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelPatchResult" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Result for a single channel patch.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.batch.ChannelPatchResult.match_name">match_name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.batch.ChannelPatchResult.status">status</span></code> (<code><span title="typing.Literal">Literal</span>['updated', 'error']</code>) </li> <li> <code><span title="yousleep_common.models.batch.ChannelPatchResult.channels_updated">channels_updated</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.batch.ChannelPatchResult.recordings_affected">recordings_affected</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.batch.ChannelPatchResult.error">error</span></code> (<code><a class="autorefs autorefs-internal" title="BatchItemError pydantic-model (yousleep_common.models.batch.BatchItemError)" href="batch/#yousleep_common.models.batch.BatchItemError">BatchItemError</a> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelRef" class="doc doc-heading"> <code>ChannelRef</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelRef" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One channel of the recording as the platform resolved it for this run.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="index pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.index)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.index">index</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="source_name pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.source_name)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.source_name">source_name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.name)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.type)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.type">type</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.channels.ChannelType)" href="../types/channels/#yousleep_common.types.channels.ChannelType">ChannelType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.unit)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.unit">unit</a></code> (<code><a class="autorefs autorefs-internal" title="PhysicalDimension (yousleep_common.types.channels.PhysicalDimension)" href="../types/channels/#yousleep_common.types.channels.PhysicalDimension">PhysicalDimension</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sample_rate = None pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.sample_rate)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.sample_rate">sample_rate</a></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="slot = None pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.slot)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.slot">slot</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="laterality = None pydantic-field (yousleep_common.models.analysis_manifest.ChannelRef.laterality)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef.laterality">laterality</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelLaterality = Literal['left', 'right'] module-attribute (yousleep_common.types.channels.ChannelLaterality)" href="../types/channels/#yousleep_common.types.channels.ChannelLaterality">ChannelLaterality</a> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.ChannelRef._drop_legacy_derivation">_drop_legacy_derivation</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.index" class="doc doc-heading"> <code class="highlight language-python"><span class="n">index</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.index" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The channel's ordinal in the recording file. Load by this.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.laterality" class="doc doc-heading"> <code class="highlight language-python"><span class="n">laterality</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.laterality" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Left or right, when inferred or declared.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The display name the user gave the channel.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.sample_rate" class="doc doc-heading"> <code class="highlight language-python"><span class="n">sample_rate</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.sample_rate" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Native sampling rate in Hz, if known.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.slot" class="doc doc-heading"> <code class="highlight language-python"><span class="n">slot</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.slot" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The label of the slot this channel fills, when the configuration declares slots.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.source_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">source_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.source_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The label as it appears in the file header, immutable.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The signal type as classified on the platform.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRef.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRef.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Physical unit, if known.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelRequirement" class="doc doc-heading"> <code>ChannelRequirement</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelRequirement" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Base channel type & requirement spec used in e.g., ExactChannel and ChannelType.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.analysis_config.channels.ChannelRequirement.type)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirement.type">type</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="requirements pydantic-field (yousleep_common.models.analysis_config.channels.ChannelRequirement.requirements)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirement.requirements">requirements</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelRequirements pydantic-model (yousleep_common.models.analysis_config.channels.ChannelRequirements)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirements">ChannelRequirements</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRequirement.requirements" class="doc doc-heading"> <code class="highlight language-python"><span class="n">requirements</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRequirement.requirements" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The requirements for the channel type.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRequirement.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRequirement.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type of channel that the analysis expects, e.g., 'EEG'.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelRequirements" class="doc doc-heading"> <code>ChannelRequirements</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelRequirements" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Channel requirements for the analysis.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="sampling_rate pydantic-field (yousleep_common.models.analysis_config.channels.ChannelRequirements.sampling_rate)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirements.sampling_rate">sampling_rate</a></code> (<code><a class="autorefs autorefs-internal" title="Range (yousleep_common.models.analysis_config.primitives.Range)" href="analysis_config/primitives/#yousleep_common.models.analysis_config.primitives.Range">Range</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="quality pydantic-field (yousleep_common.models.analysis_config.channels.ChannelRequirements.quality)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirements.quality">quality</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="QualityRequirement pydantic-model (yousleep_common.models.analysis_config.channels.QualityRequirement)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.QualityRequirement">QualityRequirement</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRequirements.quality" class="doc doc-heading"> <code class="highlight language-python"><span class="n">quality</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRequirements.quality" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Signal-quality requirements the platform checks before the channel is passed to the analysis. Empty, the default, means none.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelRequirements.sampling_rate" class="doc doc-heading"> <code class="highlight language-python"><span class="n">sampling_rate</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelRequirements.sampling_rate" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The minimum and maximum sampling rate of the channel in Hz.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelTypeRequirement" class="doc doc-heading"> <code>ChannelTypeRequirement</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelTypeRequirement" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="ChannelRequirement pydantic-model (yousleep_common.models.analysis_config.channels.ChannelRequirement)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirement">ChannelRequirement</a></code></p> <p>Represents a channel type (e.g., EEG or EOG) that the analysis expects.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.type)" href="#yousleep_common.models.ChannelRequirement.type">type</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="requirements pydantic-field (yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.requirements)" href="#yousleep_common.models.ChannelRequirement.requirements">requirements</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelRequirements pydantic-model (yousleep_common.models.analysis_config.channels.ChannelRequirements)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirements">ChannelRequirements</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="number pydantic-field (yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.number)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.number">number</a></code> (<code><a class="autorefs autorefs-internal" title="Range (yousleep_common.models.analysis_config.primitives.Range)" href="analysis_config/primitives/#yousleep_common.models.analysis_config.primitives.Range">Range</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="slots = None pydantic-field (yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.slots)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.slots">slots</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelSlot pydantic-model (yousleep_common.models.analysis_config.channels.ChannelSlot)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelSlot">ChannelSlot</a>] | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_slots() pydantic-validator (yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.validate_slots)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelTypeRequirement.validate_slots">validate_slots</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelTypeRequirement.number" class="doc doc-heading"> <code class="highlight language-python"><span class="n">number</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelTypeRequirement.number" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The minimum and maximum number of channels of the given type that the analysis expects.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelTypeRequirement.slots" class="doc doc-heading"> <code class="highlight language-python"><span class="n">slots</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelTypeRequirement.slots" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional ordered slots giving each expected channel of this type a labelled position (and optionally a required laterality). Only meaningful for fixed-count requirements: when set, 'number' must be exactly [len(slots), len(slots)]. Channels are passed to the analysis in slot order.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ChannelTypeRequirement.validate_slots" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_slots</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.ChannelTypeRequirement.validate_slots" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Slots imply a fixed count that matches the declared number range.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ChannelUpdate" class="doc doc-heading"> <code>ChannelUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ChannelUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Update model for a channel.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.channel.ChannelUpdate.name">name</span></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a></code>) </li> <li> <code><span title="yousleep_common.models.channel.ChannelUpdate.type">type</span></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sample_rate = None pydantic-field (yousleep_common.models.channel.ChannelUpdate.sample_rate)" href="channel/#yousleep_common.models.channel.ChannelUpdate.sample_rate">sample_rate</a></code> (<code><span title="pydantic.types.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.channel.ChannelUpdate.unit)" href="channel/#yousleep_common.models.channel.ChannelUpdate.unit">unit</a></code> (<code><a class="autorefs autorefs-internal" title="PhysicalDimension (yousleep_common.types.PhysicalDimension)" href="../types/#yousleep_common.types.PhysicalDimension">PhysicalDimension</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelUpdate.sample_rate" class="doc doc-heading"> <code class="highlight language-python"><span class="n">sample_rate</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelUpdate.sample_rate" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The sample rate of the channel in Hz. Must be a positive float.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ChannelUpdate.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ChannelUpdate.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The physical unit of the channel. Must be a string.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Choices" class="doc doc-heading"> <code>Choices</code> <a href="#yousleep_common.models.Choices" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.RootModel">RootModel</span></code></p> <p>Represents a list of choices where all choises have the same type and are unique.</p> <p>Each choice can be a string, integer, float, or boolean.</p> <div class="doc doc-children"> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Choices.__getitem__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__getitem__</span><span class="p">(</span><span class="n">item</span><span class="p">)</span></code> <a href="#yousleep_common.models.Choices.__getitem__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the choice at the given index.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Choices.__iter__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__iter__</span><span class="p">()</span></code> <a href="#yousleep_common.models.Choices.__iter__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return an iterator over the choices.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Choices.__len__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__len__</span><span class="p">()</span></code> <a href="#yousleep_common.models.Choices.__len__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the number of choices.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Choices.validate_choices" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_choices</span><span class="p">(</span><span class="n">values</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-classmethod"><code>classmethod</code></small> </span> <a href="#yousleep_common.models.Choices.validate_choices" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate the choices.</p> <p>Validate the choises and ensure that all choices have the same type and handles specification as root or 'choices' key in the dictionary.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Choices.validate_unique_choices" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_unique_choices</span><span class="p">()</span></code> <a href="#yousleep_common.models.Choices.validate_unique_choices" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that all choices are unique.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ComputePoolListResponse" class="doc doc-heading"> <code>ComputePoolListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ComputePoolListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of compute pools.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.runner.ComputePoolListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.runner.ComputePoolListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.runner.ComputePoolListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.ComputePoolListResponse.items">items</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ComputePoolOut pydantic-model (yousleep_common.models.runner.ComputePoolOut)" href="runner/#yousleep_common.models.runner.ComputePoolOut">ComputePoolOut</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ComputePoolOut" class="doc doc-heading"> <code>ComputePoolOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A compute pool as administrators see it.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.ComputePoolOut.id">id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.ComputePoolOut.name">name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="org_id pydantic-field (yousleep_common.models.runner.ComputePoolOut.org_id)" href="runner/#yousleep_common.models.runner.ComputePoolOut.org_id">org_id</a></code> (<code><span title="pydantic.UUID7">UUID7</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lease_seconds pydantic-field (yousleep_common.models.runner.ComputePoolOut.lease_seconds)" href="runner/#yousleep_common.models.runner.ComputePoolOut.lease_seconds">lease_seconds</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="queue_timeout_hours pydantic-field (yousleep_common.models.runner.ComputePoolOut.queue_timeout_hours)" href="runner/#yousleep_common.models.runner.ComputePoolOut.queue_timeout_hours">queue_timeout_hours</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="queued pydantic-field (yousleep_common.models.runner.ComputePoolOut.queued)" href="runner/#yousleep_common.models.runner.ComputePoolOut.queued">queued</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="held pydantic-field (yousleep_common.models.runner.ComputePoolOut.held)" href="runner/#yousleep_common.models.runner.ComputePoolOut.held">held</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="runner_seen = False pydantic-field (yousleep_common.models.runner.ComputePoolOut.runner_seen)" href="runner/#yousleep_common.models.runner.ComputePoolOut.runner_seen">runner_seen</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.ComputePoolOut.created_at">created_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ComputePoolOut.held" class="doc doc-heading"> <code class="highlight language-python"><span class="n">held</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut.held" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Jobs the pool's runners hold now, starting or running.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ComputePoolOut.lease_seconds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lease_seconds</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut.lease_seconds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>In force: the pool's own or the default.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ComputePoolOut.org_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">org_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut.org_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>None for the platform's own pool.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ComputePoolOut.queue_timeout_hours" class="doc doc-heading"> <code class="highlight language-python"><span class="n">queue_timeout_hours</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut.queue_timeout_hours" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>In force: the pool's own or the default.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ComputePoolOut.queued" class="doc doc-heading"> <code class="highlight language-python"><span class="n">queued</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut.queued" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Jobs waiting for one of the pool's runners.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ComputePoolOut.runner_seen" class="doc doc-heading"> <code class="highlight language-python"><span class="n">runner_seen</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ComputePoolOut.runner_seen" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether one of the pool's runners is taking work (a runner's <code>taking_work</code>).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ConsentAcceptItem" class="doc doc-heading"> <code>ConsentAcceptItem</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ConsentAcceptItem" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One document acceptance in a consent submission.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="document pydantic-field (yousleep_common.models.consent.ConsentAcceptItem.document)" href="consent/#yousleep_common.models.consent.ConsentAcceptItem.document">document</a></code> (<code><a class="autorefs autorefs-internal" title="ConsentDocument (yousleep_common.types.ConsentDocument)" href="../types/#yousleep_common.types.ConsentDocument">ConsentDocument</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.consent.ConsentAcceptItem.version)" href="consent/#yousleep_common.models.consent.ConsentAcceptItem.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ConsentAcceptItem.document" class="doc doc-heading"> <code class="highlight language-python"><span class="n">document</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ConsentAcceptItem.document" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The document being accepted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ConsentAcceptItem.version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ConsentAcceptItem.version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The version being accepted. Must equal the document's current version at submission time; a stale version is rejected.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ConsentAcceptRequest" class="doc doc-heading"> <code>ConsentAcceptRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ConsentAcceptRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Body of <code>POST /user/consent</code> — accept one or more documents.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="accepts pydantic-field (yousleep_common.models.consent.ConsentAcceptRequest.accepts)" href="consent/#yousleep_common.models.consent.ConsentAcceptRequest.accepts">accepts</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ConsentAcceptItem pydantic-model (yousleep_common.models.consent.ConsentAcceptItem)" href="consent/#yousleep_common.models.consent.ConsentAcceptItem">ConsentAcceptItem</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ConsentAcceptRequest.accepts" class="doc doc-heading"> <code class="highlight language-python"><span class="n">accepts</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ConsentAcceptRequest.accepts" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The document acceptances to record.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ConsentRecord" class="doc doc-heading"> <code>ConsentRecord</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ConsentRecord" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An audited acceptance row in the append-only consent ledger.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="document pydantic-field (yousleep_common.models.consent.ConsentRecord.document)" href="consent/#yousleep_common.models.consent.ConsentRecord.document">document</a></code> (<code><a class="autorefs autorefs-internal" title="ConsentDocument (yousleep_common.types.ConsentDocument)" href="../types/#yousleep_common.types.ConsentDocument">ConsentDocument</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.consent.ConsentRecord.version)" href="consent/#yousleep_common.models.consent.ConsentRecord.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="accepted_at pydantic-field (yousleep_common.models.consent.ConsentRecord.accepted_at)" href="consent/#yousleep_common.models.consent.ConsentRecord.accepted_at">accepted_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ConsentRecord.accepted_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">accepted_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ConsentRecord.accepted_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the acceptance was recorded.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ConsentRecord.document" class="doc doc-heading"> <code class="highlight language-python"><span class="n">document</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ConsentRecord.document" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The accepted document.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ConsentRecord.version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ConsentRecord.version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The accepted version.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ContactRequestCreate" class="doc doc-heading"> <code>ContactRequestCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ContactRequestCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Public submission payload (landing contact form / 'request access').</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.contact.ContactRequestCreate.type">type</span></code> (<code><a class="autorefs autorefs-internal" title="ContactRequestType (yousleep_common.models.contact.ContactRequestType)" href="contact/#yousleep_common.models.contact.ContactRequestType">ContactRequestType</a></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestCreate.email">email</span></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestCreate.name">name</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestCreate.organization">organization</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestCreate.message">message</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="website = None pydantic-field (yousleep_common.models.contact.ContactRequestCreate.website)" href="contact/#yousleep_common.models.contact.ContactRequestCreate.website">website</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ContactRequestCreate.website" class="doc doc-heading"> <code class="highlight language-python"><span class="n">website</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ContactRequestCreate.website" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Leave empty.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ContactRequestListResponse" class="doc doc-heading"> <code>ContactRequestListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ContactRequestListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Paginated list of submissions for the admin feed.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.contact.ContactRequestListResponse.requests">requests</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ContactRequestOut pydantic-model (yousleep_common.models.contact.ContactRequestOut)" href="contact/#yousleep_common.models.contact.ContactRequestOut">ContactRequestOut</a>]</code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestListResponse.total">total</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ContactRequestOut" class="doc doc-heading"> <code>ContactRequestOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ContactRequestOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Admin-facing view of a submission.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.id">id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.type">type</span></code> (<code><a class="autorefs autorefs-internal" title="ContactRequestType (yousleep_common.models.contact.ContactRequestType)" href="contact/#yousleep_common.models.contact.ContactRequestType">ContactRequestType</a></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.status">status</span></code> (<code><a class="autorefs autorefs-internal" title="ContactRequestStatus (yousleep_common.models.contact.ContactRequestStatus)" href="contact/#yousleep_common.models.contact.ContactRequestStatus">ContactRequestStatus</a></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.email">email</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.name">name</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.organization">organization</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.message">message</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.created_at">created_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><span title="yousleep_common.models.contact.ContactRequestOut.handled_at">handled_at</span></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ContactRequestStatus" class="doc doc-heading"> <code>ContactRequestStatus</code> <a href="#yousleep_common.models.ContactRequestStatus" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="str">str</span></code>, <code><span title="enum.Enum">Enum</span></code></p> <p>Triage status shown in the admin feed.</p> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ContactRequestType" class="doc doc-heading"> <code>ContactRequestType</code> <a href="#yousleep_common.models.ContactRequestType" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="str">str</span></code>, <code><span title="enum.Enum">Enum</span></code></p> <p>What the submission is about — drives the admin-feed filter.</p> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ContactRequestType.collaboration" class="doc doc-heading"> <code class="highlight language-python"><span class="n">collaboration</span> <span class="o">=</span> <span class="s1">'collaboration'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-class-attribute"><code>class-attribute</code></small> <small class="doc doc-label doc-label-instance-attribute"><code>instance-attribute</code></small> </span> <a href="#yousleep_common.models.ContactRequestType.collaboration" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Research collaboration, or a commercial enquiry.</p> <p>One topic rather than two: somebody weighing whether the platform can be used commercially should not have to declare which of the two they are before we have spoken.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ContactRequestUpdate" class="doc doc-heading"> <code>ContactRequestUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ContactRequestUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Admin update — currently only the triage status.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.contact.ContactRequestUpdate.status">status</span></code> (<code><a class="autorefs autorefs-internal" title="ContactRequestStatus (yousleep_common.models.contact.ContactRequestStatus)" href="contact/#yousleep_common.models.contact.ContactRequestStatus">ContactRequestStatus</a></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreateStudyEventsRequest" class="doc doc-heading"> <code>CreateStudyEventsRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreateStudyEventsRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request body for creating study events.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.events.CreateStudyEventsRequest.events">events</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="StudyEventInput pydantic-model (yousleep_common.models.events.StudyEventInput)" href="events/#yousleep_common.models.events.StudyEventInput">StudyEventInput</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditAdjustment" class="doc doc-heading"> <code>CreditAdjustment</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditAdjustment" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A signed change to an organization's purchased credits, with its reason.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="amount pydantic-field (yousleep_common.models.admin.CreditAdjustment.amount)" href="admin/#yousleep_common.models.admin.CreditAdjustment.amount">amount</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.admin.CreditAdjustment.reason)" href="admin/#yousleep_common.models.admin.CreditAdjustment.reason">reason</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditAdjustment.amount" class="doc doc-heading"> <code class="highlight language-python"><span class="n">amount</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditAdjustment.amount" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Amount to adjust. Positive to add, negative to deduct.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditAdjustment.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditAdjustment.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Reason for the adjustment (logged for audit trail).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditEntry" class="doc doc-heading"> <code>CreditEntry</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditEntry" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A single append-only credit ledger entry on an organization.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.credit.CreditEntry.id)" href="credit/#yousleep_common.models.credit.CreditEntry.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="org_id pydantic-field (yousleep_common.models.credit.CreditEntry.org_id)" href="credit/#yousleep_common.models.credit.CreditEntry.org_id">org_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bucket pydantic-field (yousleep_common.models.credit.CreditEntry.bucket)" href="credit/#yousleep_common.models.credit.CreditEntry.bucket">bucket</a></code> (<code><a class="autorefs autorefs-internal" title="CreditBucket (yousleep_common.types.CreditBucket)" href="../types/#yousleep_common.types.CreditBucket">CreditBucket</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="delta pydantic-field (yousleep_common.models.credit.CreditEntry.delta)" href="credit/#yousleep_common.models.credit.CreditEntry.delta">delta</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.credit.CreditEntry.reason)" href="credit/#yousleep_common.models.credit.CreditEntry.reason">reason</a></code> (<code><a class="autorefs autorefs-internal" title="CreditReason (yousleep_common.types.CreditReason)" href="../types/#yousleep_common.types.CreditReason">CreditReason</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="note = None pydantic-field (yousleep_common.models.credit.CreditEntry.note)" href="credit/#yousleep_common.models.credit.CreditEntry.note">note</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="grant_id = None pydantic-field (yousleep_common.models.credit.CreditEntry.grant_id)" href="credit/#yousleep_common.models.credit.CreditEntry.grant_id">grant_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at = None pydantic-field (yousleep_common.models.credit.CreditEntry.expires_at)" href="credit/#yousleep_common.models.credit.CreditEntry.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.credit.CreditEntry.created_at)" href="credit/#yousleep_common.models.credit.CreditEntry.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.bucket" class="doc doc-heading"> <code class="highlight language-python"><span class="n">bucket</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.bucket" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Which credit pool the entry affects</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Creation timestamp</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.delta" class="doc doc-heading"> <code class="highlight language-python"><span class="n">delta</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.delta" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Signed change in credits (positive = grant, negative = charge)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the credits granted by this entry expire, for the retired allowance; null otherwise. A grant's expiry is on the grant.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.grant_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">grant_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.grant_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The grant this entry moves, for entries in the grants bucket; null otherwise.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the ledger entry</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.note" class="doc doc-heading"> <code class="highlight language-python"><span class="n">note</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.note" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Free-text context recorded with the entry — for admin adjustments, the reason the administrator gave. None for entries created by automatic flows or predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.org_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">org_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.org_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization this entry belongs to</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEntry.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEntry.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why this entry was created</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditEstimate" class="doc doc-heading"> <code>CreditEstimate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditEstimate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What a plan would cost, priced as its runs would be.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.CreditEstimate.rows">rows</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CreditEstimateRow pydantic-model (yousleep_common.models.credit_requests.CreditEstimateRow)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimateRow">CreditEstimateRow</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="computed_credits pydantic-field (yousleep_common.models.credit_requests.CreditEstimate.computed_credits)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimate.computed_credits">computed_credits</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="buffer_pct pydantic-field (yousleep_common.models.credit_requests.CreditEstimate.buffer_pct)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimate.buffer_pct">buffer_pct</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="suggested_credits pydantic-field (yousleep_common.models.credit_requests.CreditEstimate.suggested_credits)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimate.suggested_credits">suggested_credits</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimate.buffer_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">buffer_pct</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimate.buffer_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The margin added, in percent.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimate.computed_credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">computed_credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimate.computed_credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The rows' total.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimate.suggested_credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">suggested_credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimate.suggested_credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>computed_credits plus the margin, rounded up.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditEstimateRequest" class="doc doc-heading"> <code>CreditEstimateRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A plan to price, with the buffer to add.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.CreditEstimateRequest.plan">plan</span></code> (<code><a class="autorefs autorefs-internal" title="CreditPlan pydantic-model (yousleep_common.models.credit_requests.CreditPlan)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlan">CreditPlan</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="buffer_pct = 10 pydantic-field (yousleep_common.models.credit_requests.CreditEstimateRequest.buffer_pct)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimateRequest.buffer_pct">buffer_pct</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimateRequest.buffer_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">buffer_pct</span> <span class="o">=</span> <span class="mi">10</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRequest.buffer_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Margin added to the computed cost, in percent.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditEstimateRow" class="doc doc-heading"> <code>CreditEstimateRow</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRow" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The cost of one row of a plan.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.CreditEstimateRow.analysis_config_id">analysis_config_id</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.credit_requests.CreditEstimateRow.name)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimateRow.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="runs pydantic-field (yousleep_common.models.credit_requests.CreditEstimateRow.runs)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimateRow.runs">runs</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="credits_per_run pydantic-field (yousleep_common.models.credit_requests.CreditEstimateRow.credits_per_run)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimateRow.credits_per_run">credits_per_run</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="credits pydantic-field (yousleep_common.models.credit_requests.CreditEstimateRow.credits)" href="credit_requests/#yousleep_common.models.credit_requests.CreditEstimateRow.credits">credits</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimateRow.credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRow.credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>runs × credits_per_run.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimateRow.credits_per_run" class="doc doc-heading"> <code class="highlight language-python"><span class="n">credits_per_run</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRow.credits_per_run" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits one run of an average-length recording costs.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimateRow.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRow.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis's display name.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditEstimateRow.runs" class="doc doc-heading"> <code class="highlight language-python"><span class="n">runs</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditEstimateRow.runs" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Runs in total: studies × runs per study.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditGrant" class="doc doc-heading"> <code>CreditGrant</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditGrant" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One grant of research credits to an organization.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.credit.CreditGrant.id)" href="credit/#yousleep_common.models.credit.CreditGrant.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="amount pydantic-field (yousleep_common.models.credit.CreditGrant.amount)" href="credit/#yousleep_common.models.credit.CreditGrant.amount">amount</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="remaining pydantic-field (yousleep_common.models.credit.CreditGrant.remaining)" href="credit/#yousleep_common.models.credit.CreditGrant.remaining">remaining</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="origin pydantic-field (yousleep_common.models.credit.CreditGrant.origin)" href="credit/#yousleep_common.models.credit.CreditGrant.origin">origin</a></code> (<code><a class="autorefs autorefs-internal" title="GrantOrigin (yousleep_common.types.GrantOrigin)" href="../types/#yousleep_common.types.GrantOrigin">GrantOrigin</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at = None pydantic-field (yousleep_common.models.credit.CreditGrant.expires_at)" href="credit/#yousleep_common.models.credit.CreditGrant.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="request_id = None pydantic-field (yousleep_common.models.credit.CreditGrant.request_id)" href="credit/#yousleep_common.models.credit.CreditGrant.request_id">request_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.credit.CreditGrant.created_at)" href="credit/#yousleep_common.models.credit.CreditGrant.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.amount" class="doc doc-heading"> <code class="highlight language-python"><span class="n">amount</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.amount" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits granted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the grant was made.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When what remains of the grant expires, extensions included; null for a grant that never expires.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the grant.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.origin" class="doc doc-heading"> <code class="highlight language-python"><span class="n">origin</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.origin" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How the grant came about.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.remaining" class="doc doc-heading"> <code class="highlight language-python"><span class="n">remaining</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.remaining" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits of the grant not yet spent or expired, held ones included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditGrant.request_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">request_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditGrant.request_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The request the grant was approved from, if any.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditLedgerPage" class="doc doc-heading"> <code>CreditLedgerPage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditLedgerPage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One page of an organization's credit ledger, newest first.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="entries pydantic-field (yousleep_common.models.credit.CreditLedgerPage.entries)" href="credit/#yousleep_common.models.credit.CreditLedgerPage.entries">entries</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CreditEntry pydantic-model (yousleep_common.models.credit.CreditEntry)" href="credit/#yousleep_common.models.credit.CreditEntry">CreditEntry</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.credit.CreditLedgerPage.total)" href="credit/#yousleep_common.models.credit.CreditLedgerPage.total">total</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditLedgerPage.entries" class="doc doc-heading"> <code class="highlight language-python"><span class="n">entries</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditLedgerPage.entries" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The ledger entries in this page, newest first.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditLedgerPage.total" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditLedgerPage.total" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of ledger entries for the organization.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditPackage" class="doc doc-heading"> <code>CreditPackage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditPackage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A purchasable credit package (one Stripe product).</p> <p>Assembled by the api-server from its product->credits config plus LIVE Stripe price data, so displayed amounts always match what checkout charges. Clients must render these — never hardcode packages/prices.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="product_id pydantic-field (yousleep_common.models.billing.CreditPackage.product_id)" href="billing/#yousleep_common.models.billing.CreditPackage.product_id">product_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="price_id pydantic-field (yousleep_common.models.billing.CreditPackage.price_id)" href="billing/#yousleep_common.models.billing.CreditPackage.price_id">price_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.billing.CreditPackage.name)" href="billing/#yousleep_common.models.billing.CreditPackage.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="credits pydantic-field (yousleep_common.models.billing.CreditPackage.credits)" href="billing/#yousleep_common.models.billing.CreditPackage.credits">credits</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="amount_minor pydantic-field (yousleep_common.models.billing.CreditPackage.amount_minor)" href="billing/#yousleep_common.models.billing.CreditPackage.amount_minor">amount_minor</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="currency pydantic-field (yousleep_common.models.billing.CreditPackage.currency)" href="billing/#yousleep_common.models.billing.CreditPackage.currency">currency</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPackage.amount_minor" class="doc doc-heading"> <code class="highlight language-python"><span class="n">amount_minor</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPackage.amount_minor" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Price in the currency's minor unit (e.g. euro cents).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPackage.credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPackage.credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits granted on purchase.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPackage.currency" class="doc doc-heading"> <code class="highlight language-python"><span class="n">currency</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPackage.currency" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>ISO currency code, e.g. "eur".</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPackage.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPackage.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name from the Stripe product.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPackage.price_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">price_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPackage.price_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stripe price id — pass to the checkout-session endpoint.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPackage.product_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">product_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPackage.product_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stripe product id (fulfilment key).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditPlan" class="doc doc-heading"> <code>CreditPlan</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditPlan" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What a grant is for: studies, their length, and the analyses to run.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="studies pydantic-field (yousleep_common.models.credit_requests.CreditPlan.studies)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlan.studies">studies</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="average_recording_hours pydantic-field (yousleep_common.models.credit_requests.CreditPlan.average_recording_hours)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlan.average_recording_hours">average_recording_hours</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="rows pydantic-field (yousleep_common.models.credit_requests.CreditPlan.rows)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlan.rows">rows</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CreditPlanRow pydantic-model (yousleep_common.models.credit_requests.CreditPlanRow)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlanRow">CreditPlanRow</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPlan.average_recording_hours" class="doc doc-heading"> <code class="highlight language-python"><span class="n">average_recording_hours</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPlan.average_recording_hours" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Average recording length per study, in hours.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPlan.rows" class="doc doc-heading"> <code class="highlight language-python"><span class="n">rows</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPlan.rows" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analyses to run.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPlan.studies" class="doc doc-heading"> <code class="highlight language-python"><span class="n">studies</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPlan.studies" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of studies.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditPlanRow" class="doc doc-heading"> <code>CreditPlanRow</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditPlanRow" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One analysis in a plan, and how often it runs on each study.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.credit_requests.CreditPlanRow.analysis_config_id)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlanRow.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="runs_per_study pydantic-field (yousleep_common.models.credit_requests.CreditPlanRow.runs_per_study)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlanRow.runs_per_study">runs_per_study</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPlanRow.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPlanRow.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration id.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditPlanRow.runs_per_study" class="doc doc-heading"> <code class="highlight language-python"><span class="n">runs_per_study</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditPlanRow.runs_per_study" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many times it runs on each study, e.g. once per configuration of its parameters.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditRequestDecision" class="doc doc-heading"> <code>CreditRequestDecision</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditRequestDecision" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An administrator's decision on a request, as the organization sees it.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestDecision.decision">decision</span></code> (<code><span title="typing.Literal">Literal</span>['approved', 'declined']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="amount = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestDecision.amount)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestDecision.amount">amount</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestDecision.expires_at)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestDecision.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestDecision.reason)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestDecision.reason">reason</a></code> (<code><a class="autorefs autorefs-internal" title="CreditRequestDeclineReason (yousleep_common.types.CreditRequestDeclineReason)" href="../types/#yousleep_common.types.CreditRequestDeclineReason">CreditRequestDeclineReason</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestDecision.decided_at">decided_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestDecision.amount" class="doc doc-heading"> <code class="highlight language-python"><span class="n">amount</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestDecision.amount" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits granted; null for an extension or a decline.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestDecision.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestDecision.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the grant expires after the decision; null on a decline.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestDecision.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestDecision.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why a request was declined.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditRequestOut" class="doc doc-heading"> <code>CreditRequestOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditRequestOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A request for research credits, as its organization sees it.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.id">id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.org_id">org_id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.kind">kind</span></code> (<code><a class="autorefs autorefs-internal" title="CreditRequestKind (yousleep_common.types.CreditRequestKind)" href="../types/#yousleep_common.types.CreditRequestKind">CreditRequestKind</a></code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.status">status</span></code> (<code><a class="autorefs autorefs-internal" title="CreditRequestStatus (yousleep_common.types.CreditRequestStatus)" href="../types/#yousleep_common.types.CreditRequestStatus">CreditRequestStatus</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="grant_id = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestOut.grant_id)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestOut.grant_id">grant_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="requested_by = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestOut.requested_by)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestOut.requested_by">requested_by</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.requested_by_name">requested_by_name</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="plan = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestOut.plan)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestOut.plan">plan</a></code> (<code><a class="autorefs autorefs-internal" title="CreditPlan pydantic-model (yousleep_common.models.credit_requests.CreditPlan)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlan">CreditPlan</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="computed_credits = None pydantic-field (yousleep_common.models.credit_requests.CreditRequestOut.computed_credits)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestOut.computed_credits">computed_credits</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.buffer_pct">buffer_pct</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.requested_credits">requested_credits</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.term_months">term_months</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="text pydantic-field (yousleep_common.models.credit_requests.CreditRequestOut.text)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestOut.text">text</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.created_at">created_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestOut.decision">decision</span></code> (<code><a class="autorefs autorefs-internal" title="CreditRequestDecision pydantic-model (yousleep_common.models.credit_requests.CreditRequestDecision)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestDecision">CreditRequestDecision</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestOut.computed_credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">computed_credits</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestOut.computed_credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The plan's cost when it was submitted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestOut.grant_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">grant_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestOut.grant_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The grant an extension is for.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestOut.plan" class="doc doc-heading"> <code class="highlight language-python"><span class="n">plan</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestOut.plan" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A grant request's plan; null for an extension.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestOut.requested_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">requested_by</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestOut.requested_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Who asked; null once their account is gone.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditRequestOut.text" class="doc doc-heading"> <code class="highlight language-python"><span class="n">text</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditRequestOut.text" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The purpose of a grant, or the reason for an extension.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditRequestPage" class="doc doc-heading"> <code>CreditRequestPage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditRequestPage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One page of requests, newest first.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestPage.requests">requests</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CreditRequestOut pydantic-model (yousleep_common.models.credit_requests.CreditRequestOut)" href="credit_requests/#yousleep_common.models.credit_requests.CreditRequestOut">CreditRequestOut</a>]</code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.CreditRequestPage.total">total</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.CreditedAnalysis" class="doc doc-heading"> <code>CreditedAnalysis</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.CreditedAnalysis" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An analysis a report's results came from, with the credit they carry.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.reports.CreditedAnalysis.analysis_config_id)" href="reports/#yousleep_common.models.reports.CreditedAnalysis.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.reports.CreditedAnalysis.name)" href="reports/#yousleep_common.models.reports.CreditedAnalysis.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="credit pydantic-field (yousleep_common.models.reports.CreditedAnalysis.credit)" href="reports/#yousleep_common.models.reports.CreditedAnalysis.credit">credit</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisCredit pydantic-model (yousleep_common.models.analysis_config.metadata.AnalysisCredit)" href="analysis_config/metadata/#yousleep_common.models.analysis_config.metadata.AnalysisCredit">AnalysisCredit</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditedAnalysis.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditedAnalysis.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration id.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditedAnalysis.credit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">credit</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditedAnalysis.credit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Who to credit for the analysis's results, and what to cite.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.CreditedAnalysis.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.CreditedAnalysis.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration's display name.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DeleteAnalysesRequest" class="doc doc-heading"> <code>DeleteAnalysesRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DeleteAnalysesRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.selectors._DeleteBySelectorRequest">_DeleteBySelectorRequest</span></code></p> <p>Delete the selected analyses (e.g. clear failed runs by status).</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.DeleteAnalysesRequest.expected_count">expected_count</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.selectors.DeleteAnalysesRequest.selector">selector</span></code> (<code><a class="autorefs autorefs-internal" title="AnalysisSelector pydantic-model (yousleep_common.models.selectors.AnalysisSelector)" href="selectors/#yousleep_common.models.selectors.AnalysisSelector">AnalysisSelector</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.DeleteAnalysesRequest._guard">_guard</span></code> </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DeleteRecordingsRequest" class="doc doc-heading"> <code>DeleteRecordingsRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DeleteRecordingsRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.selectors._DeleteBySelectorRequest">_DeleteBySelectorRequest</span></code></p> <p>Delete the selected recordings.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.DeleteRecordingsRequest.expected_count">expected_count</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.selectors.DeleteRecordingsRequest.selector">selector</span></code> (<code><a class="autorefs autorefs-internal" title="RecordingSelector pydantic-model (yousleep_common.models.selectors.RecordingSelector)" href="selectors/#yousleep_common.models.selectors.RecordingSelector">RecordingSelector</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.DeleteRecordingsRequest._guard">_guard</span></code> </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DeleteStudiesRequest" class="doc doc-heading"> <code>DeleteStudiesRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DeleteStudiesRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.selectors._DeleteBySelectorRequest">_DeleteBySelectorRequest</span></code></p> <p>Delete the selected studies (cascade: recordings, analyses, events).</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.DeleteStudiesRequest.expected_count">expected_count</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.selectors.DeleteStudiesRequest.selector">selector</span></code> (<code><a class="autorefs autorefs-internal" title="StudySelector pydantic-model (yousleep_common.models.selectors.StudySelector)" href="selectors/#yousleep_common.models.selectors.StudySelector">StudySelector</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.DeleteStudiesRequest._guard">_guard</span></code> </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DemoDatasetDescription" class="doc doc-heading"> <code>DemoDatasetDescription</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DemoDatasetDescription" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Description of a demo dataset (user-facing list endpoint).</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.name">name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.full_name">full_name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.description">description</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.version">version</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.source_name">source_name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.source_url">source_url</span></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.licence_name">licence_name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.licence_url">licence_url</span></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetDescription.recording_count">recording_count</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DemoDatasetRegisterRequest" class="doc doc-heading"> <code>DemoDatasetRegisterRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DemoDatasetRegisterRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request body for POST /projects/public/demo.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.demo.DemoDatasetRegisterRequest.dataset">dataset</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoDatasetRegisterRequest.project_name">project_name</span></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DemoRecordingCreate" class="doc doc-heading"> <code>DemoRecordingCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DemoRecordingCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A single recording within a demo study (admin create).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="s3_key pydantic-field (yousleep_common.models.demo.DemoRecordingCreate.s3_key)" href="demo/#yousleep_common.models.demo.DemoRecordingCreate.s3_key">s3_key</a></code> (<code><span title="str">str</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_s3_key(v) pydantic-validator (yousleep_common.models.demo.DemoRecordingCreate.validate_s3_key)" href="demo/#yousleep_common.models.demo.DemoRecordingCreate.validate_s3_key">validate_s3_key</a></code> → <code><a class="autorefs autorefs-internal" title="s3_key pydantic-field (yousleep_common.models.demo.DemoRecordingCreate.s3_key)" href="demo/#yousleep_common.models.demo.DemoRecordingCreate.s3_key">s3_key</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DemoRecordingCreate.s3_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">s3_key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DemoRecordingCreate.s3_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Key within the demo bucket, e.g. 'sleep-edfx/SC4432E0-PSG.edf'.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.DemoRecordingCreate.validate_s3_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_s3_key</span><span class="p">(</span><span class="n">v</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.DemoRecordingCreate.validate_s3_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Reject path traversal sequences and unsafe characters.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DemoStudyCreate" class="doc doc-heading"> <code>DemoStudyCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DemoStudyCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="StudyMetadata pydantic-model (yousleep_common.models.study.StudyMetadata)" href="study/#yousleep_common.models.study.StudyMetadata">StudyMetadata</a></code></p> <p>A study within a demo dataset (admin create).</p> <p>Inherits the optional subject-metadata fields (age, bmi, sex) so a demo dataset can ship pre-filled demographics — registered projects then support metadata-stratified reports out of the box. The <code>lights_off_clock</code> marker seeds the study's lights-off event the same way at registration time.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="age = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.age)" href="#yousleep_common.models.StudyMetadata.age">age</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bmi = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.bmi)" href="#yousleep_common.models.StudyMetadata.bmi">bmi</a></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sex = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.sex)" href="#yousleep_common.models.StudyMetadata.sex">sex</a></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.Sex)" href="../types/#yousleep_common.types.Sex">Sex</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.subject_key)" href="#yousleep_common.models.StudyMetadata.subject_key">subject_key</a></code> (<code><a class="autorefs autorefs-internal" title="SubjectKey = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)] module-attribute (yousleep_common.models.study.SubjectKey)" href="study/#yousleep_common.models.study.SubjectKey">SubjectKey</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="session_index = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.session_index)" href="#yousleep_common.models.StudyMetadata.session_index">session_index</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoStudyCreate.name">name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoStudyCreate.tags">tags</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="TagString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=40, pattern='^[a-zA-Z0-9](?:[a-zA-Z0-9 _.\\-]*[a-zA-Z0-9_.\\-])?$')] module-attribute (yousleep_common.fields.TagString)" href="../fields/#yousleep_common.fields.TagString">TagString</a>]</code>) </li> <li> <code><span title="yousleep_common.models.demo.DemoStudyCreate.recordings">recordings</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="DemoRecordingCreate pydantic-model (yousleep_common.models.demo.DemoRecordingCreate)" href="demo/#yousleep_common.models.demo.DemoRecordingCreate">DemoRecordingCreate</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lights_off_clock = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.lights_off_clock)" href="demo/#yousleep_common.models.demo.DemoStudyCreate.lights_off_clock">lights_off_clock</a></code> (<code><a class="autorefs autorefs-internal" title="ClockTimeStr = Annotated[str, Field(pattern='^([01]\\d|2[0-3]):[0-5]\\d(:[0-5]\\d)?$')] module-attribute (yousleep_common.fields.ClockTimeStr)" href="../fields/#yousleep_common.fields.ClockTimeStr">ClockTimeStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lights_on_clock = None pydantic-field (yousleep_common.models.demo.DemoStudyCreate.lights_on_clock)" href="demo/#yousleep_common.models.demo.DemoStudyCreate.lights_on_clock">lights_on_clock</a></code> (<code><a class="autorefs autorefs-internal" title="ClockTimeStr = Annotated[str, Field(pattern='^([01]\\d|2[0-3]):[0-5]\\d(:[0-5]\\d)?$')] module-attribute (yousleep_common.fields.ClockTimeStr)" href="../fields/#yousleep_common.fields.ClockTimeStr">ClockTimeStr</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DemoStudyCreate.lights_off_clock" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lights_off_clock</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DemoStudyCreate.lights_off_clock" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Wall clock "HH:MM" or "HH:MM:SS" in the recording's own frame, resolved against the study's recordings with overnight wrap — the same clock spelling as the lights import.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DemoStudyCreate.lights_on_clock" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lights_on_clock</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DemoStudyCreate.lights_on_clock" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Same spelling and frame as lights_off_clock. Set only when the source data records it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DistributionStats" class="doc doc-heading"> <code>DistributionStats</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DistributionStats" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Distribution statistics for a single metric across multiple observations.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="support pydantic-field (yousleep_common.models.events.DistributionStats.support)" href="events/#yousleep_common.models.events.DistributionStats.support">support</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="support_non_zero pydantic-field (yousleep_common.models.events.DistributionStats.support_non_zero)" href="events/#yousleep_common.models.events.DistributionStats.support_non_zero">support_non_zero</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="mean pydantic-field (yousleep_common.models.events.DistributionStats.mean)" href="events/#yousleep_common.models.events.DistributionStats.mean">mean</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="median pydantic-field (yousleep_common.models.events.DistributionStats.median)" href="events/#yousleep_common.models.events.DistributionStats.median">median</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="min pydantic-field (yousleep_common.models.events.DistributionStats.min)" href="events/#yousleep_common.models.events.DistributionStats.min">min</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max pydantic-field (yousleep_common.models.events.DistributionStats.max)" href="events/#yousleep_common.models.events.DistributionStats.max">max</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="std pydantic-field (yousleep_common.models.events.DistributionStats.std)" href="events/#yousleep_common.models.events.DistributionStats.std">std</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="iqr pydantic-field (yousleep_common.models.events.DistributionStats.iqr)" href="events/#yousleep_common.models.events.DistributionStats.iqr">iqr</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="p5 pydantic-field (yousleep_common.models.events.DistributionStats.p5)" href="events/#yousleep_common.models.events.DistributionStats.p5">p5</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="p25 pydantic-field (yousleep_common.models.events.DistributionStats.p25)" href="events/#yousleep_common.models.events.DistributionStats.p25">p25</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="p75 pydantic-field (yousleep_common.models.events.DistributionStats.p75)" href="events/#yousleep_common.models.events.DistributionStats.p75">p75</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="p95 pydantic-field (yousleep_common.models.events.DistributionStats.p95)" href="events/#yousleep_common.models.events.DistributionStats.p95">p95</a></code> (<code><span title="float">float</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.iqr" class="doc doc-heading"> <code class="highlight language-python"><span class="n">iqr</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.iqr" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Interquartile range (p75 - p25)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.max" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">max</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.max" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Maximum value</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.mean" class="doc doc-heading"> <code class="highlight language-python"><span class="n">mean</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.mean" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Arithmetic mean</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.median" class="doc doc-heading"> <code class="highlight language-python"><span class="n">median</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.median" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Median (50th percentile)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.min" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">min</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.min" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Minimum value</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.p25" class="doc doc-heading"> <code class="highlight language-python"><span class="n">p25</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.p25" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>25th percentile</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.p5" class="doc doc-heading"> <code class="highlight language-python"><span class="n">p5</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.p5" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>5th percentile</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.p75" class="doc doc-heading"> <code class="highlight language-python"><span class="n">p75</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.p75" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>75th percentile</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.p95" class="doc doc-heading"> <code class="highlight language-python"><span class="n">p95</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.p95" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>95th percentile</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.std" class="doc doc-heading"> <code class="highlight language-python"><span class="n">std</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.std" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Standard deviation</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.support" class="doc doc-heading"> <code class="highlight language-python"><span class="n">support</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.support" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of observations</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DistributionStats.support_non_zero" class="doc doc-heading"> <code class="highlight language-python"><span class="n">support_non_zero</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DistributionStats.support_non_zero" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of non-zero observations</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DockerSettings" class="doc doc-heading"> <code>DockerSettings</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DockerSettings" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Docker settings for building the analysis image.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="image pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.image)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.image">image</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tag pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.tag)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.tag">tag</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="digest = None pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.digest)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.digest">digest</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="base_command = '' pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.base_command)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.base_command">base_command</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="relative_build_path = '.' pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.relative_build_path)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.relative_build_path">relative_build_path</a></code> (<code><span title="str">str</span> | <span title="pathlib.Path">Path</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="remote_https_url = None pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.remote_https_url)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.remote_https_url">remote_https_url</a></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="ssh_key = None pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.ssh_key)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.ssh_key">ssh_key</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_remote_https_url(v) pydantic-validator (yousleep_common.models.analysis_config.docker.DockerSettings.validate_remote_https_url)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.validate_remote_https_url">validate_remote_https_url</a></code> → <code><a class="autorefs autorefs-internal" title="remote_https_url = None pydantic-field (yousleep_common.models.analysis_config.docker.DockerSettings.remote_https_url)" href="analysis_config/docker/#yousleep_common.models.analysis_config.docker.DockerSettings.remote_https_url">remote_https_url</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.base_command" class="doc doc-heading"> <code class="highlight language-python"><span class="n">base_command</span> <span class="o">=</span> <span class="s1">''</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.base_command" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The base command without parameters to run the analysis in the Docker container. Defaults to an empty string assuming an entry is set in the Dockerfile.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.digest" class="doc doc-heading"> <code class="highlight language-python"><span class="n">digest</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.digest" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional content digest of the Docker image, e.g. 'sha256:abc…'. When set, the image reference used to run the analysis pins these exact bytes ('image:tag@sha256:…'): the tag remains the human-readable version label, while the digest is what the container runtime resolves — a re-pushed tag can no longer change what runs. When unset, the tag alone selects the image.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.full_image_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">full_image_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.DockerSettings.full_image_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the tag form of the image name ('image:tag').</p> <p>Deliberately digest-free: registry APIs and humans address images by tag. Use :attr:<code>pinned_image_reference</code> for the reference a container runtime should run.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.image" class="doc doc-heading"> <code class="highlight language-python"><span class="n">image</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.image" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The name of the Docker image.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.pinned_image_reference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">pinned_image_reference</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.DockerSettings.pinned_image_reference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the reference to run, digest-pinned when a digest is declared.</p> <p>'image:tag@digest' with a digest, else 'image:tag'. 'NAME:TAG@DIGEST' is valid for every mainstream runtime; the runtime resolves the digest and the tag rides along as documentation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.relative_build_path" class="doc doc-heading"> <code class="highlight language-python"><span class="n">relative_build_path</span> <span class="o">=</span> <span class="s1">'.'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.relative_build_path" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The relative path to the Docker build context. This path is relative to the root of the repository. Default is the root of the repository.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.remote_https_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">remote_https_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.remote_https_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The HTTPS URL of the remote repository. This URL is used to clone the repository and build the Docker image. If the repository is private, the an SSH equivalent URL is used instead for which a valid SSH key must be registered with the ssh-agent.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.ssh_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">ssh_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.ssh_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The SSH key to use to clone the repository if the repository is private. The SSH key must be a valid private key in the OpenSSH format. If the repository is public, this field can be left empty.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.ssh_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">ssh_url</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.DockerSettings.ssh_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the SSH URL of the source repository, or None when none is declared.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerSettings.tag" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tag</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerSettings.tag" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The tag of the Docker image, e.g. 'latest' or '1.0'.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.DockerSettings.validate_remote_https_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_remote_https_url</span><span class="p">(</span><span class="n">v</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.DockerSettings.validate_remote_https_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate the remote, when one is declared, as a HTTPS URL.</p> <p>The field is optional; an explicit <code>null</code> (which is what a stored or author-facing configuration without a source repository carries) passes through untouched.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.DockerVolumeDict" class="doc doc-heading"> <code>DockerVolumeDict</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.DockerVolumeDict" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A dictionary with the parameters 'bind' and 'mode' for a docker volume.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="bind pydantic-field (yousleep_common.models.analysis_submission.DockerVolumeDict.bind)" href="analysis_submission/#yousleep_common.models.analysis_submission.DockerVolumeDict.bind">bind</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="mode pydantic-field (yousleep_common.models.analysis_submission.DockerVolumeDict.mode)" href="analysis_submission/#yousleep_common.models.analysis_submission.DockerVolumeDict.mode">mode</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerVolumeDict.bind" class="doc doc-heading"> <code class="highlight language-python"><span class="n">bind</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerVolumeDict.bind" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The path on the host machine to be mounted in the docker container.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.DockerVolumeDict.mode" class="doc doc-heading"> <code class="highlight language-python"><span class="n">mode</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.DockerVolumeDict.mode" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The mode in which the volume is mounted in the docker container.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EditStudyTagsRequest" class="doc doc-heading"> <code>EditStudyTagsRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Edit tags across the selected studies.</p> <p>Two forms, mutually exclusive: incremental (<code>add</code>/<code>remove</code>, applied where missing/present) or <code>replace</code> — set every selected study's tags to exactly this list. <code>replace: []</code> is the deliberate clear-all form.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.EditStudyTagsRequest.selector">selector</span></code> (<code><a class="autorefs autorefs-internal" title="StudySelector pydantic-model (yousleep_common.models.selectors.StudySelector)" href="selectors/#yousleep_common.models.selectors.StudySelector">StudySelector</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="add pydantic-field (yousleep_common.models.selectors.EditStudyTagsRequest.add)" href="selectors/#yousleep_common.models.selectors.EditStudyTagsRequest.add">add</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="remove pydantic-field (yousleep_common.models.selectors.EditStudyTagsRequest.remove)" href="selectors/#yousleep_common.models.selectors.EditStudyTagsRequest.remove">remove</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="replace = None pydantic-field (yousleep_common.models.selectors.EditStudyTagsRequest.replace)" href="selectors/#yousleep_common.models.selectors.EditStudyTagsRequest.replace">replace</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expected_count = None pydantic-field (yousleep_common.models.selectors.EditStudyTagsRequest.expected_count)" href="selectors/#yousleep_common.models.selectors.EditStudyTagsRequest.expected_count">expected_count</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.EditStudyTagsRequest._guard">_guard</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EditStudyTagsRequest.add" class="doc doc-heading"> <code class="highlight language-python"><span class="n">add</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsRequest.add" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Tags to add where missing.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EditStudyTagsRequest.expected_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expected_count</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsRequest.expected_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Required for filter/all selectors: the resolved count the caller saw. The server re-resolves and rejects on a mismatch.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EditStudyTagsRequest.remove" class="doc doc-heading"> <code class="highlight language-python"><span class="n">remove</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsRequest.remove" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Tags to remove where present.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EditStudyTagsRequest.replace" class="doc doc-heading"> <code class="highlight language-python"><span class="n">replace</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsRequest.replace" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set the selected studies' tags to exactly this list (an empty list clears all tags). Mutually exclusive with add/remove.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EditStudyTagsResponse" class="doc doc-heading"> <code>EditStudyTagsResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Outcome of a selector tag edit.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="count pydantic-field (yousleep_common.models.selectors.EditStudyTagsResponse.count)" href="selectors/#yousleep_common.models.selectors.EditStudyTagsResponse.count">count</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EditStudyTagsResponse.count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EditStudyTagsResponse.count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies whose tags were updated.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EnrolmentTokenOut" class="doc doc-heading"> <code>EnrolmentTokenOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EnrolmentTokenOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A new enrolment token. The token is shown here once and never again.</p> <p>With it come the storage addresses the runner reaches, which the installer takes each with <code>--storage-origin</code>, and the runner image to install. The platform's root key is not among them: the runner's release carries it and the install pins it, as a key served here could be changed by a proxy between the site and the platform, which pinning guards against.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.EnrolmentTokenOut.pool_id">pool_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.EnrolmentTokenOut.token">token</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.EnrolmentTokenOut.expires_at">expires_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_origins pydantic-field (yousleep_common.models.runner.EnrolmentTokenOut.storage_origins)" href="runner/#yousleep_common.models.runner.EnrolmentTokenOut.storage_origins">storage_origins</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><span title="yousleep_common.models.runner.EnrolmentTokenOut.runner_image">runner_image</span></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EnrolmentTokenOut.storage_origins" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_origins</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EnrolmentTokenOut.storage_origins" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The storage the runner downloads its jobs' inputs from and uploads their results to, as origins (scheme, host and port). Empty from a server that predates it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ErrorResponse" class="doc doc-heading"> <code>ErrorResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ErrorResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Structured error body returned by the API for handled errors.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="detail pydantic-field (yousleep_common.models.errors.ErrorResponse.detail)" href="errors/#yousleep_common.models.errors.ErrorResponse.detail">detail</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="code pydantic-field (yousleep_common.models.errors.ErrorResponse.code)" href="errors/#yousleep_common.models.errors.ErrorResponse.code">code</a></code> (<code><a class="autorefs autorefs-internal" title="ErrorCode (yousleep_common.types.errors.ErrorCode)" href="../types/errors/#yousleep_common.types.errors.ErrorCode">ErrorCode</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="context = None pydantic-field (yousleep_common.models.errors.ErrorResponse.context)" href="errors/#yousleep_common.models.errors.ErrorResponse.context">context</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <span title="pydantic.JsonValue">JsonValue</span>] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ErrorResponse.code" class="doc doc-heading"> <code class="highlight language-python"><span class="n">code</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ErrorResponse.code" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable machine-readable error code; branch on this, not on the detail text.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ErrorResponse.context" class="doc doc-heading"> <code class="highlight language-python"><span class="n">context</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ErrorResponse.context" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional error-specific structured fields. Values may be scalars (e.g. usage_limit_exceeded: resource, limit, current) or nested JSON (e.g. consent_required: pending = [{document, current_version}, ...]). Backward-compatible: scalar contexts are unchanged.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ErrorResponse.detail" class="doc doc-heading"> <code class="highlight language-python"><span class="n">detail</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ErrorResponse.detail" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Human-readable description of the error.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Event" class="doc doc-heading"> <code>Event</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Event" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Event data type.</p> <p>start_time_ms: Start time of the event in milliseconds relative to the recording start. end_time_ms: End time of the event in milliseconds relative to the recording start. Must be greater than or equal to start_time. If equal, the event is considered instantaneous. label: Label of the event (e.g., "Sleep stage W"). confidence: Optional confidence in [0, 1] of the event. value: Optional value associated to the event. channels: List of channels where the event was detected. If empty, the event should be considered global.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.events.Event.start_time_ms">start_time_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.events.Event.end_time_ms">end_time_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.events.Event.label">label</span></code> (<code><a class="autorefs autorefs-internal" title="EventLabel (yousleep_common.types.events.EventLabel)" href="../types/events/#yousleep_common.types.events.EventLabel">EventLabel</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="probability = None pydantic-field (yousleep_common.models.events.Event.probability)" href="events/#yousleep_common.models.events.Event.probability">probability</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="value = None pydantic-field (yousleep_common.models.events.Event.value)" href="events/#yousleep_common.models.events.Event.value">value</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.events.Event.channels">channels</span></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_time_order() pydantic-validator (yousleep_common.models.events.Event.validate_time_order)" href="events/#yousleep_common.models.events.Event.validate_time_order">validate_time_order</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Event.probability" class="doc doc-heading"> <code class="highlight language-python"><span class="n">probability</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Event.probability" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional probability/confidence in [0, 1] of the event</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Event.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Event.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional value associated to the event</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Event.validate_time_order" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_time_order</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.Event.validate_time_order" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that start time is less than end time.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventBlock" class="doc doc-heading"> <code>EventBlock</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventBlock" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>N consecutive equal-duration event slots beginning at an exact origin.</p> <p>Slot <code>i</code> spans <code>[origin_ms + i * period_ms, origin_ms + (i + 1) * period_ms)</code>. A <code>period_ms</code> of 0 marks instantaneous events, where every slot collapses onto <code>origin_ms</code>.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="origin_ms pydantic-field (yousleep_common.models.event_blocks.EventBlock.origin_ms)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.origin_ms">origin_ms</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="period_ms pydantic-field (yousleep_common.models.event_blocks.EventBlock.period_ms)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.period_ms">period_ms</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="labels pydantic-field (yousleep_common.models.event_blocks.EventBlock.labels)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.labels">labels</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="EventLabel (yousleep_common.types.events.EventLabel)" href="../types/events/#yousleep_common.types.events.EventLabel">EventLabel</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="probability = None pydantic-field (yousleep_common.models.event_blocks.EventBlock.probability)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.probability">probability</a></code> (<code><span title="list">list</span>[<span title="float">float</span> | None] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="value = None pydantic-field (yousleep_common.models.event_blocks.EventBlock.value)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.value">value</a></code> (<code><span title="list">list</span>[<span title="float">float</span> | None] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channels pydantic-field (yousleep_common.models.event_blocks.EventBlock.channels)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.channels">channels</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_parallel_arrays() pydantic-validator (yousleep_common.models.event_blocks.EventBlock.validate_parallel_arrays)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock.validate_parallel_arrays">validate_parallel_arrays</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.channels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channels</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlock.channels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>List of channels the block's events were detected on, shared by every slot. If empty, the events should be considered global.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.end_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">end_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.EventBlock.end_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the end of the final slot.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.labels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">labels</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlock.labels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>One label per slot. Labels may vary from slot to slot.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.origin_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">origin_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlock.origin_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Start time of the first slot in milliseconds relative to the recording start.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.period_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">period_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlock.period_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Duration of every slot in milliseconds. 0 marks instantaneous events.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.probability" class="doc doc-heading"> <code class="highlight language-python"><span class="n">probability</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlock.probability" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional probability/confidence in [0, 1] per slot. None when no slot in the block carries a probability; individual entries may still be None.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.slot_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">slot_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.EventBlock.slot_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the number of slots.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlock.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlock.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional value per slot. None when no slot in the block carries a value; individual entries may still be None.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.EventBlock.validate_parallel_arrays" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_parallel_arrays</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.EventBlock.validate_parallel_arrays" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that the optional per-slot arrays match the slot count.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventBlocksDocument" class="doc doc-heading"> <code>EventBlocksDocument</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventBlocksDocument" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The events output document an analysis container writes.</p> <p>A versioned envelope around a list of blocks. Block order is meaningful and must be preserved: it is the canonical order the encoding produces, and consumers rely on it being stable.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="format_version = 1 pydantic-field (yousleep_common.models.event_blocks.EventBlocksDocument.format_version)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlocksDocument.format_version">format_version</a></code> (<code><span title="typing.Literal">Literal</span>[1]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="blocks pydantic-field (yousleep_common.models.event_blocks.EventBlocksDocument.blocks)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlocksDocument.blocks">blocks</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="EventBlock pydantic-model (yousleep_common.models.event_blocks.EventBlock)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlock">EventBlock</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="device = None pydantic-field (yousleep_common.models.event_blocks.EventBlocksDocument.device)" href="event_blocks/#yousleep_common.models.event_blocks.EventBlocksDocument.device">device</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <span title="typing.Any">Any</span>] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlocksDocument.blocks" class="doc doc-heading"> <code class="highlight language-python"><span class="n">blocks</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlocksDocument.blocks" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The event blocks, in canonical order.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlocksDocument.device" class="doc doc-heading"> <code class="highlight language-python"><span class="n">device</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlocksDocument.device" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional provenance recorded by the producing analysis: software and model identity, versions, an input content hash, and any further descriptive fields the producer chooses. Opaque to the platform — carried with the document, never interpreted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlocksDocument.event_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">event_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.EventBlocksDocument.event_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the total number of events across all blocks.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventBlocksDocument.format_version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">format_version</span> <span class="o">=</span> <span class="mi">1</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventBlocksDocument.format_version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Version of the events document format.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventListResponse" class="doc doc-heading"> <code>EventListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of an analysis's events.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.events.EventListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.events.EventListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.events.EventListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.events.EventListResponse.events">events</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="Event pydantic-model (yousleep_common.models.events.Event)" href="events/#yousleep_common.models.events.Event">Event</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventStats" class="doc doc-heading"> <code>EventStats</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventStats" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A model for statistics computed over a list of events of similar type.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="event_type pydantic-field (yousleep_common.models.events.EventStats.event_type)" href="events/#yousleep_common.models.events.EventStats.event_type">event_type</a></code> (<code><a class="autorefs autorefs-internal" title="EventType pydantic-model (yousleep_common.models.events.EventType)" href="events/#yousleep_common.models.events.EventType">EventType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="stats pydantic-field (yousleep_common.models.events.EventStats.stats)" href="events/#yousleep_common.models.events.EventStats.stats">stats</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <span title="float">float</span> | <span title="int">int</span>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventStats.event_type" class="doc doc-heading"> <code class="highlight language-python"><span class="n">event_type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventStats.event_type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type of event for which the statistics were computed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventStats.stats" class="doc doc-heading"> <code class="highlight language-python"><span class="n">stats</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventStats.stats" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Dictionary of statistics computed over the events.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventType" class="doc doc-heading"> <code>EventType</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventType" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Model for the type of an event.</p> <p>Represents an event label with a type, where types are e.g., 'instant-probabilistic' or 'interval-discrete'.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.events.EventType.label)" href="events/#yousleep_common.models.events.EventType.label">label</a></code> (<code><a class="autorefs autorefs-internal" title="EventLabel (yousleep_common.types.events.EventLabel)" href="../types/events/#yousleep_common.types.events.EventLabel">EventLabel</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channels pydantic-field (yousleep_common.models.events.EventType.channels)" href="events/#yousleep_common.models.events.EventType.channels">channels</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="instant = False pydantic-field (yousleep_common.models.events.EventType.instant)" href="events/#yousleep_common.models.events.EventType.instant">instant</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="probabilistic = False pydantic-field (yousleep_common.models.events.EventType.probabilistic)" href="events/#yousleep_common.models.events.EventType.probabilistic">probabilistic</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="valued = False pydantic-field (yousleep_common.models.events.EventType.valued)" href="events/#yousleep_common.models.events.EventType.valued">valued</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventType.channels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channels</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventType.channels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>List of channels where the event was detected. If empty, the event should be considered global.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventType.instant" class="doc doc-heading"> <code class="highlight language-python"><span class="n">instant</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventType.instant" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the event is instantaneous or not.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventType.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventType.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The label of the event, e.g., 'sleep-stage'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventType.probabilistic" class="doc doc-heading"> <code class="highlight language-python"><span class="n">probabilistic</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventType.probabilistic" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the event has an associated 'probability' value in [0, 1] or not.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventType.valued" class="doc doc-heading"> <code class="highlight language-python"><span class="n">valued</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventType.valued" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the event has an associated 'value' or not.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.EventType.infer_from_concrete_event" class="doc doc-heading"> <code class="highlight language-python"><span class="n">infer_from_concrete_event</span><span class="p">(</span><span class="n">event</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-classmethod"><code>classmethod</code></small> </span> <a href="#yousleep_common.models.EventType.infer_from_concrete_event" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Infer the type of the event from a concrete event.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventsExportParams" class="doc doc-heading"> <code>EventsExportParams</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventsExportParams" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Cohort selection for an <code>events-zip</code> export.</p> <p>The archive bundles the events file of every completed analysis in the cohort, one file per analysis, each byte-identical to the single analysis download. The cohort is the project, narrowed by whichever selectors are given: <code>study_ids</code> keeps the named studies, <code>analysis_ids</code> keeps the named analyses; both together keep the analyses that satisfy both. Ids outside the project are ignored.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="study_ids = None pydantic-field (yousleep_common.models.report_export.EventsExportParams.study_ids)" href="report_export/#yousleep_common.models.report_export.EventsExportParams.study_ids">study_ids</a></code> (<code><span title="list">list</span>[<span title="uuid.UUID">UUID</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_ids = None pydantic-field (yousleep_common.models.report_export.EventsExportParams.analysis_ids)" href="report_export/#yousleep_common.models.report_export.EventsExportParams.analysis_ids">analysis_ids</a></code> (<code><span title="list">list</span>[<span title="uuid.UUID">UUID</span>] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsExportParams.analysis_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_ids</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsExportParams.analysis_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analyses whose events files join the zip; those not completed, or not in the project, are left out. None = no narrowing by analysis.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsExportParams.study_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_ids</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsExportParams.study_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies whose completed analyses' events files join the zip. None = no narrowing by study.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventsFilter" class="doc doc-heading"> <code>EventsFilter</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventsFilter" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="SignalWindow pydantic-model (yousleep_common.models.channel.SignalWindow)" href="channel/#yousleep_common.models.channel.SignalWindow">SignalWindow</a></code></p> <p>Filter parameters for querying events.</p> <p>This is a data container for filter criteria. Actual filtering is performed at the database layer for performance. Two independent filters are applied:</p> <ol> <li> <p><strong>Time window filter</strong>: Restricts events to a time range. Events outside the window are excluded. Controlled by window_start_time_ms, window_end_time_ms, and window_mode. Most modes only <em>select</em> whole events; CLIP additionally truncates the ones that straddle a boundary.</p> </li> <li> <p><strong>Label filter</strong>: Filters by event labels/types. Controlled by labels and match_mode:</p> </li> <li>INCLUDE mode: Only events matching the labels are returned.</li> <li>EXCLUDE mode: Events matching the labels are removed.</li> </ol> <p>Both filters are independent - the time window acts as a "crop" operation, while match_mode only affects label filtering.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="window_start_time_ms = 0 pydantic-field (yousleep_common.models.events.EventsFilter.window_start_time_ms)" href="#yousleep_common.models.SignalWindow.window_start_time_ms">window_start_time_ms</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="window_end_time_ms = None pydantic-field (yousleep_common.models.events.EventsFilter.window_end_time_ms)" href="#yousleep_common.models.SignalWindow.window_end_time_ms">window_end_time_ms</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="labels = None pydantic-field (yousleep_common.models.events.EventsFilter.labels)" href="events/#yousleep_common.models.events.EventsFilter.labels">labels</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="EventLabel (yousleep_common.types.events.EventLabel)" href="../types/events/#yousleep_common.types.events.EventLabel">EventLabel</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="match_mode = MatchModes.INCLUDE pydantic-field (yousleep_common.models.events.EventsFilter.match_mode)" href="events/#yousleep_common.models.events.EventsFilter.match_mode">match_mode</a></code> (<code><a class="autorefs autorefs-internal" title="MatchModes (yousleep_common.types.events.MatchModes)" href="../types/events/#yousleep_common.types.events.MatchModes">MatchModes</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="window_mode = WindowFilterModes.START pydantic-field (yousleep_common.models.events.EventsFilter.window_mode)" href="events/#yousleep_common.models.events.EventsFilter.window_mode">window_mode</a></code> (<code><a class="autorefs autorefs-internal" title="WindowFilterModes (yousleep_common.types.events.WindowFilterModes)" href="../types/events/#yousleep_common.types.events.WindowFilterModes">WindowFilterModes</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_time_order() pydantic-validator (yousleep_common.models.events.EventsFilter.validate_time_order)" href="#yousleep_common.models.SignalWindow.validate_time_order">validate_time_order</a></code> </li> <li> <code><a class="autorefs autorefs-internal" title="validate_window_mode() pydantic-validator (yousleep_common.models.events.EventsFilter.validate_window_mode)" href="events/#yousleep_common.models.events.EventsFilter.validate_window_mode">validate_window_mode</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsFilter.labels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">labels</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsFilter.labels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Filter events by labels. If set, only events with labels in this list are considered for inclusion/exclusion based on match_mode. If None, label filtering is disabled.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsFilter.match_mode" class="doc doc-heading"> <code class="highlight language-python"><span class="n">match_mode</span> <span class="o">=</span> <span class="n">MatchModes</span><span class="o">.</span><span class="n">INCLUDE</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsFilter.match_mode" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Controls how label filtering works. INCLUDE: only include events matching the labels list. EXCLUDE: exclude events matching the labels list. Note: This only affects label filtering, not window filtering.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsFilter.window_mode" class="doc doc-heading"> <code class="highlight language-python"><span class="n">window_mode</span> <span class="o">=</span> <span class="n">WindowFilterModes</span><span class="o">.</span><span class="n">START</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsFilter.window_mode" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Controls how the time window filter matches events. START: match events starting within the window. END: match events ending within the window. CONTAIN: match events fully contained in the window. CLIP: match events overlapping the window and truncate them to it, so returned durations sum to at most the window's width. Events outside the window are always excluded regardless of match_mode.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.EventsFilter.validate_window_mode" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_window_mode</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.EventsFilter.validate_window_mode" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that required window times are provided for the selected window mode.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.EventsOutputLimits" class="doc doc-heading"> <code>EventsOutputLimits</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.EventsOutputLimits" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Bounds on an events document read from an analysis container.</p> <p>The document is written by the container, so its size is chosen by whoever built the image. Every reader applies these bounds before the content is decoded or expanded: a small gzip payload can decompress to gigabytes, and a small block document can describe millions of events. The defaults leave ample room for a full night scored every second with every class's probability, which is well under a million events.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="max_file_bytes = 64 * 1024 * 1024 pydantic-field (yousleep_common.models.event_blocks.EventsOutputLimits.max_file_bytes)" href="event_blocks/#yousleep_common.models.event_blocks.EventsOutputLimits.max_file_bytes">max_file_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_decompressed_bytes = 128 * 1024 * 1024 pydantic-field (yousleep_common.models.event_blocks.EventsOutputLimits.max_decompressed_bytes)" href="event_blocks/#yousleep_common.models.event_blocks.EventsOutputLimits.max_decompressed_bytes">max_decompressed_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_events = 2000000 pydantic-field (yousleep_common.models.event_blocks.EventsOutputLimits.max_events)" href="event_blocks/#yousleep_common.models.event_blocks.EventsOutputLimits.max_events">max_events</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsOutputLimits.max_decompressed_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_decompressed_bytes</span> <span class="o">=</span> <span class="mi">128</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsOutputLimits.max_decompressed_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Largest document accepted after gzip decompression.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsOutputLimits.max_events" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_events</span> <span class="o">=</span> <span class="mi">2000000</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsOutputLimits.max_events" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Most events a document may describe across its blocks.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.EventsOutputLimits.max_file_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_file_bytes</span> <span class="o">=</span> <span class="mi">64</span> <span class="o">*</span> <span class="mi">1024</span> <span class="o">*</span> <span class="mi">1024</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.EventsOutputLimits.max_file_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Largest document accepted as stored, compressed or not.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ExactChannelRequirement" class="doc doc-heading"> <code>ExactChannelRequirement</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ExactChannelRequirement" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="ChannelRequirement pydantic-model (yousleep_common.models.analysis_config.channels.ChannelRequirement)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirement">ChannelRequirement</a></code></p> <p>An exact channel (a montage such as <code>C3-M2</code>) that the analysis expects.</p> <p>Matched by identity, not by string: the platform reads every recording label into a canonical form, so <code>C3-M2</code> here matches <code>C3-A2</code>, <code>C3M2</code> and <code>EEG C3-M2</code> in a file. <code>any_of</code> lists acceptable alternatives in order of preference. A montage the file does not carry is prepared before upload; the platform does not derive channels.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.analysis_config.channels.ExactChannelRequirement.type)" href="#yousleep_common.models.ChannelRequirement.type">type</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="requirements pydantic-field (yousleep_common.models.analysis_config.channels.ExactChannelRequirement.requirements)" href="#yousleep_common.models.ChannelRequirement.requirements">requirements</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelRequirements pydantic-model (yousleep_common.models.analysis_config.channels.ChannelRequirements)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelRequirements">ChannelRequirements</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.analysis_config.channels.ExactChannelRequirement.name)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ExactChannelRequirement.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="any_of pydantic-field (yousleep_common.models.analysis_config.channels.ExactChannelRequirement.any_of)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ExactChannelRequirement.any_of">any_of</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelName = Annotated[str, StringConstraints(min_length=1, max_length=16)] module-attribute (yousleep_common.fields.ChannelName)" href="../fields/#yousleep_common.fields.ChannelName">ChannelName</a>]</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_config.channels.ExactChannelRequirement._alternatives_are_distinct">_alternatives_are_distinct</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ExactChannelRequirement.any_of" class="doc doc-heading"> <code class="highlight language-python"><span class="n">any_of</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ExactChannelRequirement.any_of" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Alternatives accepted in place of <code>name</code>, in order of preference; the first one present in the recording is used, e.g. ['C4-M1'] for a requirement named 'C3-M2'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ExactChannelRequirement.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ExactChannelRequirement.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The canonical name of the channel the analysis expects, e.g. 'C3-M2'. Matched against each recording channel's canonical identity.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ExtensionRequestCreate" class="doc doc-heading"> <code>ExtensionRequestCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ExtensionRequestCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A request for more time on a grant.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="term_months pydantic-field (yousleep_common.models.credit_requests.ExtensionRequestCreate.term_months)" href="credit_requests/#yousleep_common.models.credit_requests.ExtensionRequestCreate.term_months">term_months</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.credit_requests.ExtensionRequestCreate.reason)" href="credit_requests/#yousleep_common.models.credit_requests.ExtensionRequestCreate.reason">reason</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ExtensionRequestCreate.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ExtensionRequestCreate.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why more time is needed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ExtensionRequestCreate.term_months" class="doc doc-heading"> <code class="highlight language-python"><span class="n">term_months</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ExtensionRequestCreate.term_months" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The extra time asked for, from the offered terms.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.FileInput" class="doc doc-heading"> <code>FileInput</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.FileInput" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A file the manifest points at inside the container.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.FileInput.path">path</span></code> (<code><span title="str">str</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.FileInput._inside_the_container">_inside_the_container</span></code> → <code><span title="yousleep_common.models.analysis_manifest.FileInput.path">path</span></code> </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.GrantRequestCreate" class="doc doc-heading"> <code>GrantRequestCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.GrantRequestCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A request for a new research grant.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.credit_requests.GrantRequestCreate.plan">plan</span></code> (<code><a class="autorefs autorefs-internal" title="CreditPlan pydantic-model (yousleep_common.models.credit_requests.CreditPlan)" href="credit_requests/#yousleep_common.models.credit_requests.CreditPlan">CreditPlan</a></code>) </li> <li> <code><span title="yousleep_common.models.credit_requests.GrantRequestCreate.buffer_pct">buffer_pct</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="requested_credits pydantic-field (yousleep_common.models.credit_requests.GrantRequestCreate.requested_credits)" href="credit_requests/#yousleep_common.models.credit_requests.GrantRequestCreate.requested_credits">requested_credits</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="term_months pydantic-field (yousleep_common.models.credit_requests.GrantRequestCreate.term_months)" href="credit_requests/#yousleep_common.models.credit_requests.GrantRequestCreate.term_months">term_months</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="purpose pydantic-field (yousleep_common.models.credit_requests.GrantRequestCreate.purpose)" href="credit_requests/#yousleep_common.models.credit_requests.GrantRequestCreate.purpose">purpose</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.GrantRequestCreate.purpose" class="doc doc-heading"> <code class="highlight language-python"><span class="n">purpose</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.GrantRequestCreate.purpose" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the research is, in a few sentences.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.GrantRequestCreate.requested_credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">requested_credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.GrantRequestCreate.requested_credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The amount asked for, which the requester chooses.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.GrantRequestCreate.term_months" class="doc doc-heading"> <code class="highlight language-python"><span class="n">term_months</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.GrantRequestCreate.term_months" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How long the grant should last, from the offered terms.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HeaderRule" class="doc doc-heading"> <code>HeaderRule</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HeaderRule" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The pseudonymisation rule a runner applies to a recording's EDF header.</p> <p>The runner hashes the recording as fetched, then rewrites the header of its local copy before the container starts: the identification fields are blanked, and the start date is replaced by EDF+'s unknown date unless <code>keep_dates</code>. The container reads only that copy.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="keep_dates pydantic-field (yousleep_common.models.runner.HeaderRule.keep_dates)" href="runner/#yousleep_common.models.runner.HeaderRule.keep_dates">keep_dates</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HeaderRule.keep_dates" class="doc doc-heading"> <code class="highlight language-python"><span class="n">keep_dates</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HeaderRule.keep_dates" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Keep the start date, or replace it with EDF+'s unknown date.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HeartbeatLease" class="doc doc-heading"> <code>HeartbeatLease</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HeartbeatLease" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One held lease, as its runner reports it.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.HeartbeatLease.lease_id">lease_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.HeartbeatLease.attempt">attempt</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.HeartbeatLease.phase">phase</span></code> (<code><a class="autorefs autorefs-internal" title="LeasePhase (yousleep_common.types.runner.LeasePhase)" href="../types/runner/#yousleep_common.types.runner.LeasePhase">LeasePhase</a></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HeartbeatRequest" class="doc doc-heading"> <code>HeartbeatRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HeartbeatRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A runner reports the leases it holds.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.HeartbeatRequest.leases">leases</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="HeartbeatLease pydantic-model (yousleep_common.models.runner.HeartbeatLease)" href="runner/#yousleep_common.models.runner.HeartbeatLease">HeartbeatLease</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HeartbeatResponse" class="doc doc-heading"> <code>HeartbeatResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HeartbeatResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An answer for each reported lease.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.HeartbeatResponse.answers">answers</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LeaseAnswer pydantic-model (yousleep_common.models.runner.LeaseAnswer)" href="runner/#yousleep_common.models.runner.LeaseAnswer">LeaseAnswer</a>]</code>) </li> <li> <code><span title="yousleep_common.models.runner.HeartbeatResponse.lease_seconds">lease_seconds</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HistoryResponse" class="doc doc-heading"> <code>HistoryResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HistoryResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>Response model for the analysis history endpoint.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.history.HistoryResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.history.HistoryResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.history.HistoryResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.history.HistoryResponse.history">history</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AnalysisOut pydantic-model (yousleep_common.models.analysis.AnalysisOut)" href="analysis/#yousleep_common.models.analysis.AnalysisOut">AnalysisOut</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="count pydantic-field (yousleep_common.models.history.HistoryResponse.count)" href="history/#yousleep_common.models.history.HistoryResponse.count">count</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HistoryResponse.count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HistoryResponse.count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total analyses matching the query. Deprecated duplicate of <code>total</code>; read <code>total</code> instead.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HypnogramModel" class="doc doc-heading"> <code>HypnogramModel</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HypnogramModel" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A staging hypnogram: stage lanes + step segments over the recording.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="duration_ms pydantic-field (yousleep_common.models.charts.HypnogramModel.duration_ms)" href="charts/#yousleep_common.models.charts.HypnogramModel.duration_ms">duration_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lanes pydantic-field (yousleep_common.models.charts.HypnogramModel.lanes)" href="charts/#yousleep_common.models.charts.HypnogramModel.lanes">lanes</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="segments pydantic-field (yousleep_common.models.charts.HypnogramModel.segments)" href="charts/#yousleep_common.models.charts.HypnogramModel.segments">segments</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="HypnogramSegment pydantic-model (yousleep_common.models.charts.HypnogramSegment)" href="charts/#yousleep_common.models.charts.HypnogramSegment">HypnogramSegment</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="ticks pydantic-field (yousleep_common.models.charts.HypnogramModel.ticks)" href="charts/#yousleep_common.models.charts.HypnogramModel.ticks">ticks</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AxisTick pydantic-model (yousleep_common.models.charts.AxisTick)" href="charts/#yousleep_common.models.charts.AxisTick">AxisTick</a>]</code>) </li> <li> <code><span title="yousleep_common.models.charts.HypnogramModel.lights_off_fraction">lights_off_fraction</span></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.charts.HypnogramModel.lights_on_fraction">lights_on_fraction</span></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="svg = None pydantic-field (yousleep_common.models.charts.HypnogramModel.svg)" href="charts/#yousleep_common.models.charts.HypnogramModel.svg">svg</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramModel.duration_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">duration_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramModel.duration_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recording length the fractions map over.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramModel.lanes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lanes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramModel.lanes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stage labels, top lane first.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramModel.segments" class="doc doc-heading"> <code class="highlight language-python"><span class="n">segments</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramModel.segments" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Runs in time order.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramModel.svg" class="doc doc-heading"> <code class="highlight language-python"><span class="n">svg</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramModel.svg" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-rendered inline SVG of this hypnogram — same contract as BoxplotModel.svg: CSS-variable colors, stable classes, <title> tooltips, data-* attributes; None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramModel.ticks" class="doc doc-heading"> <code class="highlight language-python"><span class="n">ticks</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramModel.ticks" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Time-axis ticks (value in ms).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.HypnogramSegment" class="doc doc-heading"> <code>HypnogramSegment</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.HypnogramSegment" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One constant-stage run of the hypnogram step curve.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="lane pydantic-field (yousleep_common.models.charts.HypnogramSegment.lane)" href="charts/#yousleep_common.models.charts.HypnogramSegment.lane">lane</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.charts.HypnogramSegment.label)" href="charts/#yousleep_common.models.charts.HypnogramSegment.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="start_ms pydantic-field (yousleep_common.models.charts.HypnogramSegment.start_ms)" href="charts/#yousleep_common.models.charts.HypnogramSegment.start_ms">start_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="end_ms pydantic-field (yousleep_common.models.charts.HypnogramSegment.end_ms)" href="charts/#yousleep_common.models.charts.HypnogramSegment.end_ms">end_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.charts.HypnogramSegment.start_fraction">start_fraction</span></code> (<code><span title="float">float</span></code>) </li> <li> <code><span title="yousleep_common.models.charts.HypnogramSegment.end_fraction">end_fraction</span></code> (<code><span title="float">float</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramSegment.end_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">end_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramSegment.end_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Run end, ms from recording start.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramSegment.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramSegment.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Event label of the run (e.g. 'Sleep stage N2').</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramSegment.lane" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lane</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramSegment.lane" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Row index into HypnogramModel.lanes.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.HypnogramSegment.start_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">start_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.HypnogramSegment.start_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Run start, ms from recording start.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Identification" class="doc doc-heading"> <code>Identification</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Identification" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Analysis identification information.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_config.metadata.Identification.name">name</span></code> (<code><a class="autorefs autorefs-internal" title="AnalysisConfigNameStr = Annotated[str, Field(min_length=4, max_length=64, pattern='^[A-Z]{1}[a-zA-Z -]*\\d*$', examples=['U-Sleep Research v1'], description="The user friendly name of the analysis. Can include spaces and hypens. Must be between 4 and 64 characters long. Must start with an uppercase letter and afterwards contain only alphabetical characters, spaces or hypens ('-'). Cannot end in a space nor a hyphen. Can end with digits, such as 'v2', to name a second lineage of the same method.")] module-attribute (yousleep_common.fields.AnalysisConfigNameStr)" href="../fields/#yousleep_common.fields.AnalysisConfigNameStr">AnalysisConfigNameStr</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.analysis_config.metadata.Identification.id)" href="analysis_config/metadata/#yousleep_common.models.analysis_config.metadata.Identification.id">id</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisConfigIdStr = Annotated[str, Field(min_length=4, max_length=64, pattern='^[a-z-]*\\d*$', examples=['u-sleep-research-v1'], description="The machine-readable identifier of the analysis configuration. Must be between 4 and 64 characters long. Must contain only lowercase letters, hyphens ('-'), and optionally end with digits (e.g., 'u-sleep-research-v1'). The id names one lineage of comparable results and never changes once registered.")] module-attribute (yousleep_common.fields.AnalysisConfigIdStr)" href="../fields/#yousleep_common.fields.AnalysisConfigIdStr">AnalysisConfigIdStr</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="family = None pydantic-field (yousleep_common.models.analysis_config.metadata.Identification.family)" href="analysis_config/metadata/#yousleep_common.models.analysis_config.metadata.Identification.family">family</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_config.metadata.Identification._derive_id_from_name">_derive_id_from_name</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Identification.family" class="doc doc-heading"> <code class="highlight language-python"><span class="n">family</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Identification.family" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The family the analysis belongs to: the versions and variants of one method share it (e.g. 'U-Sleep'), so clients can group and filter by it. Unset, the analysis is a family of its own, named by its name.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Identification.family_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">family_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.Identification.family_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The family to group the analysis under: its own name when it sets none.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Identification.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Identification.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The machine-readable identifier: one lineage of comparable results, never changed once registered. Derived from the name when omitted (lower case, spaces as hyphens); set it explicitly only to keep an existing id when the name changes.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.InputCoverage" class="doc doc-heading"> <code>InputCoverage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.InputCoverage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>How many of a step's recordings have one input its analysis declares.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.batch.InputCoverage.name)" href="batch/#yousleep_common.models.batch.InputCoverage.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.batch.InputCoverage.kind">kind</span></code> (<code><span title="typing.Literal">Literal</span>['channel_type', 'channel', 'subject_value']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="required pydantic-field (yousleep_common.models.batch.InputCoverage.required)" href="batch/#yousleep_common.models.batch.InputCoverage.required">required</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="present pydantic-field (yousleep_common.models.batch.InputCoverage.present)" href="batch/#yousleep_common.models.batch.InputCoverage.present">present</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InputCoverage.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InputCoverage.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>As the configuration declares it: a channel type (EEG), an exact channel (C3-M2), or a subject value (age).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InputCoverage.present" class="doc doc-heading"> <code class="highlight language-python"><span class="n">present</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InputCoverage.present" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recordings that have it: at least the declared minimum of channels, or a recorded value.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InputCoverage.required" class="doc doc-heading"> <code class="highlight language-python"><span class="n">required</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InputCoverage.required" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether a recording without it is refused. An optional input is used when the recording has it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Inputs" class="doc doc-heading"> <code>Inputs</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Inputs" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Represents the inputs of the analysis.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="recording pydantic-field (yousleep_common.models.analysis_config.io_models.Inputs.recording)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Inputs.recording">recording</a></code> (<code><a class="autorefs autorefs-internal" title="RecordingInput pydantic-model (yousleep_common.models.analysis_config.channels.RecordingInput)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput">RecordingInput</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="events = None pydantic-field (yousleep_common.models.analysis_config.io_models.Inputs.events)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Inputs.events">events</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="EventType pydantic-model (yousleep_common.models.events.EventType)" href="events/#yousleep_common.models.events.EventType">EventType</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="metadata = None pydantic-field (yousleep_common.models.analysis_config.io_models.Inputs.metadata)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Inputs.metadata">metadata</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="MetadataType (yousleep_common.types.MetadataType)" href="../types/#yousleep_common.types.MetadataType">MetadataType</a>] | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_at_least_one_input(data) pydantic-validator (yousleep_common.models.analysis_config.io_models.Inputs.validate_at_least_one_input)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Inputs.validate_at_least_one_input">validate_at_least_one_input</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Inputs.events" class="doc doc-heading"> <code class="highlight language-python"><span class="n">events</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Inputs.events" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The list of typed event that the analysis requires in the input.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Inputs.metadata" class="doc doc-heading"> <code class="highlight language-python"><span class="n">metadata</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Inputs.metadata" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional list of metadata type input for the analysis, e.g., 'age'.Can be None if the analysis does not require metadata.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Inputs.recording" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Inputs.recording" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The recording input for the analysis. Can be None if the analysis does not require a recording input.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Inputs.validate_at_least_one_input" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_at_least_one_input</span><span class="p">(</span><span class="n">data</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.Inputs.validate_at_least_one_input" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that at least one of 'recording', 'events' and 'metadata' is set.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.InvitationCreate" class="doc doc-heading"> <code>InvitationCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.InvitationCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Invite an email address into a team organization.</p> <p>The invitee receives a link that is valid for a limited time and can be accepted once, by an account whose verified email matches the address.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.invitation.InvitationCreate.email)" href="invitation/#yousleep_common.models.invitation.InvitationCreate.email">email</a></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role = MembershipRole.MEMBER pydantic-field (yousleep_common.models.invitation.InvitationCreate.role)" href="invitation/#yousleep_common.models.invitation.InvitationCreate.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.organization.MembershipRole)" href="../types/organization/#yousleep_common.types.organization.MembershipRole">MembershipRole</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.invitation.InvitationCreate._lower">_lower</span></code> → <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.invitation.InvitationCreate.email)" href="invitation/#yousleep_common.models.invitation.InvitationCreate.email">email</a></code> </li> <li> <code><span title="yousleep_common.models.invitation.InvitationCreate._not_owner">_not_owner</span></code> → <code><a class="autorefs autorefs-internal" title="role = MembershipRole.MEMBER pydantic-field (yousleep_common.models.invitation.InvitationCreate.role)" href="invitation/#yousleep_common.models.invitation.InvitationCreate.role">role</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationCreate.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationCreate.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The address to invite.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationCreate.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span> <span class="o">=</span> <span class="n">MembershipRole</span><span class="o">.</span><span class="n">MEMBER</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationCreate.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The role the invitee joins with: member or admin.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.InvitationOut" class="doc doc-heading"> <code>InvitationOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.InvitationOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An invitation as listed to the organization's admins. Never carries the token.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.invitation.InvitationOut.id)" href="invitation/#yousleep_common.models.invitation.InvitationOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="org_id pydantic-field (yousleep_common.models.invitation.InvitationOut.org_id)" href="invitation/#yousleep_common.models.invitation.InvitationOut.org_id">org_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.invitation.InvitationOut.email)" href="invitation/#yousleep_common.models.invitation.InvitationOut.email">email</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.invitation.InvitationOut.role)" href="invitation/#yousleep_common.models.invitation.InvitationOut.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.organization.MembershipRole)" href="../types/organization/#yousleep_common.types.organization.MembershipRole">MembershipRole</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="invited_by_name = None pydantic-field (yousleep_common.models.invitation.InvitationOut.invited_by_name)" href="invitation/#yousleep_common.models.invitation.InvitationOut.invited_by_name">invited_by_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="status pydantic-field (yousleep_common.models.invitation.InvitationOut.status)" href="invitation/#yousleep_common.models.invitation.InvitationOut.status">status</a></code> (<code><a class="autorefs autorefs-internal" title="InvitationStatus (yousleep_common.types.organization.InvitationStatus)" href="../types/organization/#yousleep_common.types.organization.InvitationStatus">InvitationStatus</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.invitation.InvitationOut.created_at)" href="invitation/#yousleep_common.models.invitation.InvitationOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at pydantic-field (yousleep_common.models.invitation.InvitationOut.expires_at)" href="invitation/#yousleep_common.models.invitation.InvitationOut.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When it was sent.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The invited address.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When it stops being acceptable.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the invitation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.invited_by_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">invited_by_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.invited_by_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the member who sent it, if set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.org_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">org_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.org_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization the invitation is for.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The role the invitee joins with.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationOut.status" class="doc doc-heading"> <code class="highlight language-python"><span class="n">status</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationOut.status" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where the invitation stands.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.InvitationPreview" class="doc doc-heading"> <code>InvitationPreview</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.InvitationPreview" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What an invitation link is for, shown before accepting it.</p> <p>Returned to whoever holds the link; it names the organization, the inviter and the invited address so the holder can sign in with the right account or register it.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="organization_name pydantic-field (yousleep_common.models.invitation.InvitationPreview.organization_name)" href="invitation/#yousleep_common.models.invitation.InvitationPreview.organization_name">organization_name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="inviter_name = None pydantic-field (yousleep_common.models.invitation.InvitationPreview.inviter_name)" href="invitation/#yousleep_common.models.invitation.InvitationPreview.inviter_name">inviter_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.invitation.InvitationPreview.email)" href="invitation/#yousleep_common.models.invitation.InvitationPreview.email">email</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.invitation.InvitationPreview.role)" href="invitation/#yousleep_common.models.invitation.InvitationPreview.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.organization.MembershipRole)" href="../types/organization/#yousleep_common.types.organization.MembershipRole">MembershipRole</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at pydantic-field (yousleep_common.models.invitation.InvitationPreview.expires_at)" href="invitation/#yousleep_common.models.invitation.InvitationPreview.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationPreview.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationPreview.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The invited address.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationPreview.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationPreview.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the link stops working.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationPreview.inviter_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">inviter_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationPreview.inviter_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the member who sent it, if set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationPreview.organization_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">organization_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationPreview.organization_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization inviting.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationPreview.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationPreview.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The role the invitee joins with.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.InvitationToken" class="doc doc-heading"> <code>InvitationToken</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.InvitationToken" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The secret from an invitation link, presented to look it up or accept it.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="token pydantic-field (yousleep_common.models.invitation.InvitationToken.token)" href="invitation/#yousleep_common.models.invitation.InvitationToken.token">token</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.InvitationToken.token" class="doc doc-heading"> <code class="highlight language-python"><span class="n">token</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.InvitationToken.token" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The token from the invitation link.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.JobClaim" class="doc doc-heading"> <code>JobClaim</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.JobClaim" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The resources a leased job may use, as the runner enforces them.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.JobClaim.cores">cores</span></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="memory_mib pydantic-field (yousleep_common.models.runner.JobClaim.memory_mib)" href="runner/#yousleep_common.models.runner.JobClaim.memory_mib">memory_mib</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.JobClaim.wall_clock_seconds">wall_clock_seconds</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.JobClaim.gpus">gpus</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.JobClaim.memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">memory_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.JobClaim.memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A hard limit with no swap. Never 0, which a container runtime reads as no limit.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.KeyCertificate" class="doc doc-heading"> <code>KeyCertificate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.KeyCertificate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A root key's statement that <code>public_key</code> signs as <code>kid</code> until <code>not_after</code>.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.KeyCertificate.kid">kid</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="serial pydantic-field (yousleep_common.models.runner.KeyCertificate.serial)" href="runner/#yousleep_common.models.runner.KeyCertificate.serial">serial</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="public_key pydantic-field (yousleep_common.models.runner.KeyCertificate.public_key)" href="runner/#yousleep_common.models.runner.KeyCertificate.public_key">public_key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.KeyCertificate.not_after">not_after</span></code> (<code><span title="pydantic.AwareDatetime">AwareDatetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="signature pydantic-field (yousleep_common.models.runner.KeyCertificate.signature)" href="runner/#yousleep_common.models.runner.KeyCertificate.signature">signature</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.KeyCertificate.public_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">public_key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.KeyCertificate.public_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The certified key's 32 raw bytes, base64.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.KeyCertificate.serial" class="doc doc-heading"> <code class="highlight language-python"><span class="n">serial</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.KeyCertificate.serial" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Higher than every earlier certificate's; a runner refuses a serial below the highest it has seen.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.KeyCertificate.signature" class="doc doc-heading"> <code class="highlight language-python"><span class="n">signature</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.KeyCertificate.signature" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The root key's Ed25519 signature, base64.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Lease" class="doc doc-heading"> <code>Lease</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Lease" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One job a runner now holds, until <code>expires_at</code> unless heartbeated.</p> <p>Exactly the field of its kind is set; the platform leaves the others out of the answer, so a runner that does not know a kind never meets its field.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.Lease.lease_id">lease_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="attempt pydantic-field (yousleep_common.models.runner.Lease.attempt)" href="runner/#yousleep_common.models.runner.Lease.attempt">attempt</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.Lease.kind">kind</span></code> (<code><a class="autorefs autorefs-internal" title="LeaseKind (yousleep_common.types.runner.LeaseKind)" href="../types/runner/#yousleep_common.types.runner.LeaseKind">LeaseKind</a></code>) </li> <li> <code><span title="yousleep_common.models.runner.Lease.expires_at">expires_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.Lease.analysis">analysis</span></code> (<code><a class="autorefs autorefs-internal" title="LeasedAnalysis pydantic-model (yousleep_common.models.runner.LeasedAnalysis)" href="runner/#yousleep_common.models.runner.LeasedAnalysis">LeasedAnalysis</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.Lease.ingest">ingest</span></code> (<code><a class="autorefs autorefs-internal" title="LeasedIngest pydantic-model (yousleep_common.models.runner.LeasedIngest)" href="runner/#yousleep_common.models.runner.LeasedIngest">LeasedIngest</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.Lease.delete">delete</span></code> (<code><a class="autorefs autorefs-internal" title="LeasedDelete pydantic-model (yousleep_common.models.runner.LeasedDelete)" href="runner/#yousleep_common.models.runner.LeasedDelete">LeasedDelete</a> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.runner.Lease._its_job_alone">_its_job_alone</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Lease.attempt" class="doc doc-heading"> <code class="highlight language-python"><span class="n">attempt</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Lease.attempt" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Sent back with every report on it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeaseAnswer" class="doc doc-heading"> <code>LeaseAnswer</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeaseAnswer" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What to do with one reported lease.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseAnswer.lease_id">lease_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseAnswer.answer">answer</span></code> (<code><a class="autorefs autorefs-internal" title="HeartbeatAnswer (yousleep_common.types.runner.HeartbeatAnswer)" href="../types/runner/#yousleep_common.types.runner.HeartbeatAnswer">HeartbeatAnswer</a></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeaseFile" class="doc doc-heading"> <code>LeaseFile</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeaseFile" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A file the container reads or writes, and the URL that moves it.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseFile.container_path">container_path</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="url pydantic-field (yousleep_common.models.runner.LeaseFile.url)" href="runner/#yousleep_common.models.runner.LeaseFile.url">url</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="header_rule = None pydantic-field (yousleep_common.models.runner.LeaseFile.header_rule)" href="runner/#yousleep_common.models.runner.LeaseFile.header_rule">header_rule</a></code> (<code><a class="autorefs autorefs-internal" title="HeaderRule pydantic-model (yousleep_common.models.runner.HeaderRule)" href="runner/#yousleep_common.models.runner.HeaderRule">HeaderRule</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseFile.header_rule" class="doc doc-heading"> <code class="highlight language-python"><span class="n">header_rule</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseFile.header_rule" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>On the recording among a job's inputs: the rule its local copy's header is rewritten by before the container reads it. Absent on every other file.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseFile.url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">url</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseFile.url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A presigned URL: GET for an input, PUT for an output. Used exactly as given: normalising it would break its signature.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeaseRequest" class="doc doc-heading"> <code>LeaseRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeaseRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A runner asks for work that fits its free room and its local policy.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseRequest.free">free</span></code> (<code><a class="autorefs autorefs-internal" title="RunnerCapacity pydantic-model (yousleep_common.models.runner.RunnerCapacity)" href="runner/#yousleep_common.models.runner.RunnerCapacity">RunnerCapacity</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="capacity = None pydantic-field (yousleep_common.models.runner.LeaseRequest.capacity)" href="runner/#yousleep_common.models.runner.LeaseRequest.capacity">capacity</a></code> (<code><a class="autorefs autorefs-internal" title="RunnerCapacity pydantic-model (yousleep_common.models.runner.RunnerCapacity)" href="runner/#yousleep_common.models.runner.RunnerCapacity">RunnerCapacity</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="largest_job pydantic-field (yousleep_common.models.runner.LeaseRequest.largest_job)" href="runner/#yousleep_common.models.runner.LeaseRequest.largest_job">largest_job</a></code> (<code><a class="autorefs autorefs-internal" title="RunnerCapacity pydantic-model (yousleep_common.models.runner.RunnerCapacity)" href="runner/#yousleep_common.models.runner.RunnerCapacity">RunnerCapacity</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="kinds pydantic-field (yousleep_common.models.runner.LeaseRequest.kinds)" href="runner/#yousleep_common.models.runner.LeaseRequest.kinds">kinds</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LeaseKind (yousleep_common.types.runner.LeaseKind)" href="../types/runner/#yousleep_common.types.runner.LeaseKind">LeaseKind</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="wait_seconds = 30 pydantic-field (yousleep_common.models.runner.LeaseRequest.wait_seconds)" href="runner/#yousleep_common.models.runner.LeaseRequest.wait_seconds">wait_seconds</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseRequest.capacity" class="doc doc-heading"> <code class="highlight language-python"><span class="n">capacity</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseRequest.capacity" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The runner's total room, as its configuration offers it now. The platform keeps it as the runner's capacity, so a change made after enrolment reaches the platform with the runner's next request for work. Unset, the capacity last reported, or the one the runner enrolled with, stands.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseRequest.kinds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">kinds</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseRequest.kinds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The kinds of job the runner takes.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseRequest.largest_job" class="doc doc-heading"> <code class="highlight language-python"><span class="n">largest_job</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseRequest.largest_job" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The largest single job the runner's local policy allows.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseRequest.wait_seconds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">wait_seconds</span> <span class="o">=</span> <span class="mi">30</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseRequest.wait_seconds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How long the platform may hold the request open for work.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeaseResponse" class="doc doc-heading"> <code>LeaseResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeaseResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The jobs leased to the runner; empty when none came in time.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseResponse.leases">leases</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="Lease pydantic-model (yousleep_common.models.runner.Lease)" href="runner/#yousleep_common.models.runner.Lease">Lease</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lease_seconds pydantic-field (yousleep_common.models.runner.LeaseResponse.lease_seconds)" href="runner/#yousleep_common.models.runner.LeaseResponse.lease_seconds">lease_seconds</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseResponse.lease_seconds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lease_seconds</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseResponse.lease_seconds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How long a lease lasts without a heartbeat. The runner reports every :func:<code>heartbeat_seconds</code> of it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeaseResultRequest" class="doc doc-heading"> <code>LeaseResultRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeaseResultRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>How a leased job ended.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.attempt">attempt</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.ended">ended</span></code> (<code><a class="autorefs autorefs-internal" title="JobEnd (yousleep_common.types.runner.JobEnd)" href="../types/runner/#yousleep_common.types.runner.JobEnd">JobEnd</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="exit_code = None pydantic-field (yousleep_common.models.runner.LeaseResultRequest.exit_code)" href="runner/#yousleep_common.models.runner.LeaseResultRequest.exit_code">exit_code</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="return_reason = None pydantic-field (yousleep_common.models.runner.LeaseResultRequest.return_reason)" href="runner/#yousleep_common.models.runner.LeaseResultRequest.return_reason">return_reason</a></code> (<code><a class="autorefs autorefs-internal" title="ReturnReason (yousleep_common.types.runner.ReturnReason)" href="../types/runner/#yousleep_common.types.runner.ReturnReason">ReturnReason</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.stdout_tail">stdout_tail</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.stderr_tail">stderr_tail</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.outputs">outputs</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="UploadedFile pydantic-model (yousleep_common.models.runner.UploadedFile)" href="runner/#yousleep_common.models.runner.UploadedFile">UploadedFile</a>]</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.attestations">attestations</span></code> (<code><a class="autorefs autorefs-internal" title="ResultAttestations pydantic-model (yousleep_common.models.runner.ResultAttestations)" href="runner/#yousleep_common.models.runner.ResultAttestations">ResultAttestations</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="peak_memory_mib = None pydantic-field (yousleep_common.models.runner.LeaseResultRequest.peak_memory_mib)" href="runner/#yousleep_common.models.runner.LeaseResultRequest.peak_memory_mib">peak_memory_mib</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest.duration_seconds">duration_seconds</span></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="header_changed = None pydantic-field (yousleep_common.models.runner.LeaseResultRequest.header_changed)" href="runner/#yousleep_common.models.runner.LeaseResultRequest.header_changed">header_changed</a></code> (<code><span title="bool">bool</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseResultRequest._one_way_to_end">_one_way_to_end</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseResultRequest.exit_code" class="doc doc-heading"> <code class="highlight language-python"><span class="n">exit_code</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseResultRequest.exit_code" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set exactly when the job ended <code>exited</code>.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseResultRequest.header_changed" class="doc doc-heading"> <code class="highlight language-python"><span class="n">header_changed</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseResultRequest.header_changed" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>For an ingest that fetched its recording: whether the header rule changed the copy's header. The platform refuses an uploaded copy the rule changed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseResultRequest.peak_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">peak_memory_mib</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseResultRequest.peak_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The container's peak memory, as it recorded it on exit.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseResultRequest.return_reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">return_reason</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeaseResultRequest.return_reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set exactly when the job ended <code>returned</code>.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeaseResultRequest.succeeded" class="doc doc-heading"> <code class="highlight language-python"><span class="n">succeeded</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.LeaseResultRequest.succeeded" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the container exited 0 by itself.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeaseResultResponse" class="doc doc-heading"> <code>LeaseResultResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeaseResultResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The platform's decision on a posted result.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeaseResultResponse.decision">decision</span></code> (<code><a class="autorefs autorefs-internal" title="ResultDecision (yousleep_common.types.runner.ResultDecision)" href="../types/runner/#yousleep_common.types.runner.ResultDecision">ResultDecision</a></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LeasedAnalysis" class="doc doc-heading"> <code>LeasedAnalysis</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LeasedAnalysis" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Everything a runner needs to run one analysis, and nothing more.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.LeasedAnalysis.analysis_id">analysis_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="image pydantic-field (yousleep_common.models.runner.LeasedAnalysis.image)" href="runner/#yousleep_common.models.runner.LeasedAnalysis.image">image</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="manifest pydantic-field (yousleep_common.models.runner.LeasedAnalysis.manifest)" href="runner/#yousleep_common.models.runner.LeasedAnalysis.manifest">manifest</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisManifest pydantic-model (yousleep_common.models.analysis_manifest.AnalysisManifest)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.AnalysisManifest">AnalysisManifest</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="manifest_path pydantic-field (yousleep_common.models.runner.LeasedAnalysis.manifest_path)" href="runner/#yousleep_common.models.runner.LeasedAnalysis.manifest_path">manifest_path</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.LeasedAnalysis.inputs">inputs</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LeaseFile pydantic-model (yousleep_common.models.runner.LeaseFile)" href="runner/#yousleep_common.models.runner.LeaseFile">LeaseFile</a>]</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeasedAnalysis.outputs">outputs</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LeaseFile pydantic-model (yousleep_common.models.runner.LeaseFile)" href="runner/#yousleep_common.models.runner.LeaseFile">LeaseFile</a>]</code>) </li> <li> <code><span title="yousleep_common.models.runner.LeasedAnalysis.claim">claim</span></code> (<code><a class="autorefs autorefs-internal" title="JobClaim pydantic-model (yousleep_common.models.runner.JobClaim)" href="runner/#yousleep_common.models.runner.JobClaim">JobClaim</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeasedAnalysis.image" class="doc doc-heading"> <code class="highlight language-python"><span class="n">image</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeasedAnalysis.image" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The container image to run.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeasedAnalysis.manifest" class="doc doc-heading"> <code class="highlight language-python"><span class="n">manifest</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeasedAnalysis.manifest" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The one document the container receives.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LeasedAnalysis.manifest_path" class="doc doc-heading"> <code class="highlight language-python"><span class="n">manifest_path</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LeasedAnalysis.manifest_path" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where to write the manifest, relative to the work directory.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LegalDocument" class="doc doc-heading"> <code>LegalDocument</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LegalDocument" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="LegalDocumentShort pydantic-model (yousleep_common.models.legal.LegalDocumentShort)" href="legal/#yousleep_common.models.legal.LegalDocumentShort">LegalDocumentShort</a></code></p> <p>Response model for terms and conditions, privacy policies, and licences.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="category pydantic-field (yousleep_common.models.legal.LegalDocument.category)" href="#yousleep_common.models.LegalDocumentIdentifier.category">category</a></code> (<code><span title="typing.Literal">Literal</span>['terms-and-conditions', 'privacy-policy', 'licence', 'site-agreement']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.legal.LegalDocument.type)" href="#yousleep_common.models.LegalDocumentIdentifier.type">type</a></code> (<code><span title="typing.Literal">Literal</span>['standard', 'non-commercial', 'commercial']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.legal.LegalDocument.version)" href="#yousleep_common.models.LegalDocumentIdentifier.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.legal.LegalDocument.name)" href="#yousleep_common.models.LegalDocumentShort.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="valid_from pydantic-field (yousleep_common.models.legal.LegalDocument.valid_from)" href="#yousleep_common.models.LegalDocumentShort.valid_from">valid_from</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="valid_until pydantic-field (yousleep_common.models.legal.LegalDocument.valid_until)" href="#yousleep_common.models.LegalDocumentShort.valid_until">valid_until</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="summary = None pydantic-field (yousleep_common.models.legal.LegalDocument.summary)" href="#yousleep_common.models.LegalDocumentShort.summary">summary</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="content pydantic-field (yousleep_common.models.legal.LegalDocument.content)" href="legal/#yousleep_common.models.legal.LegalDocument.content">content</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocument.content" class="doc doc-heading"> <code class="highlight language-python"><span class="n">content</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocument.content" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The content of the document.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LegalDocumentIdentifier" class="doc doc-heading"> <code>LegalDocumentIdentifier</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LegalDocumentIdentifier" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A model to uniquely identify a legal document.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="category pydantic-field (yousleep_common.models.legal.LegalDocumentIdentifier.category)" href="legal/#yousleep_common.models.legal.LegalDocumentIdentifier.category">category</a></code> (<code><span title="typing.Literal">Literal</span>['terms-and-conditions', 'privacy-policy', 'licence', 'site-agreement']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.legal.LegalDocumentIdentifier.type)" href="legal/#yousleep_common.models.legal.LegalDocumentIdentifier.type">type</a></code> (<code><span title="typing.Literal">Literal</span>['standard', 'non-commercial', 'commercial']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.legal.LegalDocumentIdentifier.version)" href="legal/#yousleep_common.models.legal.LegalDocumentIdentifier.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentIdentifier.category" class="doc doc-heading"> <code class="highlight language-python"><span class="n">category</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentIdentifier.category" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The category of the document. The site agreement is what an organisation's owner accepts before it may run analyses or keep recordings on its own hardware.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentIdentifier.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentIdentifier.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type of the document within its category: 'standard' for terms, privacy and site documents, 'non-commercial' or 'commercial' for licences.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentIdentifier.version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentIdentifier.version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The version of the document as a posive integer.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LegalDocumentShort" class="doc doc-heading"> <code>LegalDocumentShort</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LegalDocumentShort" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="LegalDocumentIdentifier pydantic-model (yousleep_common.models.legal.LegalDocumentIdentifier)" href="legal/#yousleep_common.models.legal.LegalDocumentIdentifier">LegalDocumentIdentifier</a></code></p> <p>Response model for legal documents.</p> <p>Does not contain the content itself. See LegalDocument for the full response.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="category pydantic-field (yousleep_common.models.legal.LegalDocumentShort.category)" href="#yousleep_common.models.LegalDocumentIdentifier.category">category</a></code> (<code><span title="typing.Literal">Literal</span>['terms-and-conditions', 'privacy-policy', 'licence', 'site-agreement']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.legal.LegalDocumentShort.type)" href="#yousleep_common.models.LegalDocumentIdentifier.type">type</a></code> (<code><span title="typing.Literal">Literal</span>['standard', 'non-commercial', 'commercial']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.legal.LegalDocumentShort.version)" href="#yousleep_common.models.LegalDocumentIdentifier.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.legal.LegalDocumentShort.name)" href="legal/#yousleep_common.models.legal.LegalDocumentShort.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="valid_from pydantic-field (yousleep_common.models.legal.LegalDocumentShort.valid_from)" href="legal/#yousleep_common.models.legal.LegalDocumentShort.valid_from">valid_from</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="valid_until pydantic-field (yousleep_common.models.legal.LegalDocumentShort.valid_until)" href="legal/#yousleep_common.models.legal.LegalDocumentShort.valid_until">valid_until</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="summary = None pydantic-field (yousleep_common.models.legal.LegalDocumentShort.summary)" href="legal/#yousleep_common.models.legal.LegalDocumentShort.summary">summary</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentShort.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentShort.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The name of the document.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentShort.summary" class="doc doc-heading"> <code class="highlight language-python"><span class="n">summary</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentShort.summary" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>An optional short summary of the document.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentShort.valid_from" class="doc doc-heading"> <code class="highlight language-python"><span class="n">valid_from</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentShort.valid_from" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The date from which the document is valid.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LegalDocumentShort.valid_until" class="doc doc-heading"> <code class="highlight language-python"><span class="n">valid_until</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LegalDocumentShort.valid_until" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>If null, the document is valid indefinitely.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Licence" class="doc doc-heading"> <code>Licence</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Licence" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="LegalDocumentIdentifier pydantic-model (yousleep_common.models.legal.LegalDocumentIdentifier)" href="legal/#yousleep_common.models.legal.LegalDocumentIdentifier">LegalDocumentIdentifier</a></code></p> <p>Licence information for an analysis.</p> <p>Similar to LegalDocumentIdentifier but with type fixed to 'licence' and version defaulting to 'latest' version.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="category = 'licence' pydantic-field (yousleep_common.models.legal.Licence.category)" href="legal/#yousleep_common.models.legal.Licence.category">category</a></code> (<code><span title="typing.Literal">Literal</span>['licence']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.legal.Licence.type)" href="legal/#yousleep_common.models.legal.Licence.type">type</a></code> (<code><span title="typing.Literal">Literal</span>['non-commercial', 'commercial']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version = 'latest' pydantic-field (yousleep_common.models.legal.Licence.version)" href="legal/#yousleep_common.models.legal.Licence.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | <span title="typing.Literal">Literal</span>['latest']</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Licence.category" class="doc doc-heading"> <code class="highlight language-python"><span class="n">category</span> <span class="o">=</span> <span class="s1">'licence'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Licence.category" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type is always 'licence'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Licence.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Licence.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The licence class the analysis is offered under.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Licence.version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">version</span> <span class="o">=</span> <span class="s1">'latest'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Licence.version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The version of the licence. An integer or 'latest'.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LightsInstant" class="doc doc-heading"> <code>LightsInstant</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LightsInstant" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One lights marker in exactly one spelling.</p> <p><code>clock</code> is primary: wall clock in the recording's own frame, resolved per study with overnight wrap (a 23:30 recording start with lights_off 00:15 lands the next calendar day). <code>datetime</code> is an absolute wall-clock datetime in the same frame; <code>elapsed_ms</code> counts from recording start.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="clock = None pydantic-field (yousleep_common.models.study_import.LightsInstant.clock)" href="study_import/#yousleep_common.models.study_import.LightsInstant.clock">clock</a></code> (<code><a class="autorefs autorefs-internal" title="ClockTimeStr = Annotated[str, Field(pattern='^([01]\\d|2[0-3]):[0-5]\\d(:[0-5]\\d)?$')] module-attribute (yousleep_common.fields.ClockTimeStr)" href="../fields/#yousleep_common.fields.ClockTimeStr">ClockTimeStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="datetime = None pydantic-field (yousleep_common.models.study_import.LightsInstant.datetime)" href="study_import/#yousleep_common.models.study_import.LightsInstant.datetime">datetime</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.LightsInstant.elapsed_ms">elapsed_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.study_import.LightsInstant._exactly_one_spelling">_exactly_one_spelling</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LightsInstant.clock" class="doc doc-heading"> <code class="highlight language-python"><span class="n">clock</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LightsInstant.clock" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Wall clock "HH:MM" or "HH:MM:SS". Only resolvable while the study's recording span is ≤ 24 h; longer spans error per item (use datetime or elapsed_ms).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LightsInstant.datetime" class="doc doc-heading"> <code class="highlight language-python"><span class="n">datetime</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LightsInstant.datetime" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>ISO datetime in the recording's wall-clock frame (any timezone suffix is ignored; times are read in the recording's own wall-clock frame).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LineChartModel" class="doc doc-heading"> <code>LineChartModel</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LineChartModel" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Lines over a shared value axis and a shared, ordered time axis.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="domain_min pydantic-field (yousleep_common.models.charts.LineChartModel.domain_min)" href="charts/#yousleep_common.models.charts.LineChartModel.domain_min">domain_min</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="domain_max pydantic-field (yousleep_common.models.charts.LineChartModel.domain_max)" href="charts/#yousleep_common.models.charts.LineChartModel.domain_max">domain_max</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit_label pydantic-field (yousleep_common.models.charts.LineChartModel.unit_label)" href="charts/#yousleep_common.models.charts.LineChartModel.unit_label">unit_label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="value_format = 'decimal' pydantic-field (yousleep_common.models.charts.LineChartModel.value_format)" href="charts/#yousleep_common.models.charts.LineChartModel.value_format">value_format</a></code> (<code><span title="typing.Literal">Literal</span>['duration-hours', 'decimal']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="decimals = 1 pydantic-field (yousleep_common.models.charts.LineChartModel.decimals)" href="charts/#yousleep_common.models.charts.LineChartModel.decimals">decimals</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="ticks pydantic-field (yousleep_common.models.charts.LineChartModel.ticks)" href="charts/#yousleep_common.models.charts.LineChartModel.ticks">ticks</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AxisTick pydantic-model (yousleep_common.models.charts.AxisTick)" href="charts/#yousleep_common.models.charts.AxisTick">AxisTick</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="x_ticks pydantic-field (yousleep_common.models.charts.LineChartModel.x_ticks)" href="charts/#yousleep_common.models.charts.LineChartModel.x_ticks">x_ticks</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AxisTick pydantic-model (yousleep_common.models.charts.AxisTick)" href="charts/#yousleep_common.models.charts.AxisTick">AxisTick</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="series pydantic-field (yousleep_common.models.charts.LineChartModel.series)" href="charts/#yousleep_common.models.charts.LineChartModel.series">series</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LineSeries pydantic-model (yousleep_common.models.charts.LineSeries)" href="charts/#yousleep_common.models.charts.LineSeries">LineSeries</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="svg = None pydantic-field (yousleep_common.models.charts.LineChartModel.svg)" href="charts/#yousleep_common.models.charts.LineChartModel.svg">svg</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.decimals" class="doc doc-heading"> <code class="highlight language-python"><span class="n">decimals</span> <span class="o">=</span> <span class="mi">1</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.decimals" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Decimal places for 'decimal' formatting.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.domain_max" class="doc doc-heading"> <code class="highlight language-python"><span class="n">domain_max</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.domain_max" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Value-axis maximum, in the axis unit.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.domain_min" class="doc doc-heading"> <code class="highlight language-python"><span class="n">domain_min</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.domain_min" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Value-axis minimum, in the axis unit.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.series" class="doc doc-heading"> <code class="highlight language-python"><span class="n">series</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.series" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The lines, in legend order.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.svg" class="doc doc-heading"> <code class="highlight language-python"><span class="n">svg</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.svg" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-rendered inline SVG of this chart, the same renderer behind live pages and document exports. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.ticks" class="doc doc-heading"> <code class="highlight language-python"><span class="n">ticks</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.ticks" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Value-axis ticks at nice intervals.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.unit_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit_label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.unit_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Value-axis caption including the unit, e.g. 'TST (min)'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.value_format" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value_format</span> <span class="o">=</span> <span class="s1">'decimal'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.value_format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How a consumer renders one of this chart's VALUES as text, the same rule the axis ticks already follow.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineChartModel.x_ticks" class="doc doc-heading"> <code class="highlight language-python"><span class="n">x_ticks</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineChartModel.x_ticks" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Time-axis ticks: one per bin, in order, labelled as the bins are. <code>value</code> is the bin's index.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LinePoint" class="doc doc-heading"> <code>LinePoint</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LinePoint" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One observation on a line: where it sits on both axes.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="value pydantic-field (yousleep_common.models.charts.LinePoint.value)" href="charts/#yousleep_common.models.charts.LinePoint.value">value</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="fraction pydantic-field (yousleep_common.models.charts.LinePoint.fraction)" href="charts/#yousleep_common.models.charts.LinePoint.fraction">fraction</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="x_fraction pydantic-field (yousleep_common.models.charts.LinePoint.x_fraction)" href="charts/#yousleep_common.models.charts.LinePoint.x_fraction">x_fraction</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.charts.LinePoint.label)" href="charts/#yousleep_common.models.charts.LinePoint.label">label</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LinePoint.fraction" class="doc doc-heading"> <code class="highlight language-python"><span class="n">fraction</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LinePoint.fraction" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The value on the shared value domain, 0…1.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LinePoint.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LinePoint.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The time bin it belongs to, as drawn.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LinePoint.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LinePoint.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The observation, in the axis unit.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LinePoint.x_fraction" class="doc doc-heading"> <code class="highlight language-python"><span class="n">x_fraction</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LinePoint.x_fraction" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where along the time axis it sits, 0…1.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LineSeries" class="doc doc-heading"> <code>LineSeries</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LineSeries" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One line: a subject's observations in time order.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.charts.LineSeries.key)" href="charts/#yousleep_common.models.charts.LineSeries.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.charts.LineSeries.label)" href="charts/#yousleep_common.models.charts.LineSeries.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="color_token = None pydantic-field (yousleep_common.models.charts.LineSeries.color_token)" href="charts/#yousleep_common.models.charts.LineSeries.color_token">color_token</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="dash = None pydantic-field (yousleep_common.models.charts.LineSeries.dash)" href="charts/#yousleep_common.models.charts.LineSeries.dash">dash</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="points pydantic-field (yousleep_common.models.charts.LineSeries.points)" href="charts/#yousleep_common.models.charts.LineSeries.points">points</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LinePoint pydantic-model (yousleep_common.models.charts.LinePoint)" href="charts/#yousleep_common.models.charts.LinePoint">LinePoint</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineSeries.color_token" class="doc doc-heading"> <code class="highlight language-python"><span class="n">color_token</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineSeries.color_token" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Brand color token NAME the line uses; consumers resolve it (CSS variable live, tokens.yaml literal in PDFs).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineSeries.dash" class="doc doc-heading"> <code class="highlight language-python"><span class="n">dash</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineSeries.dash" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>SVG dash pattern, e.g. '5 3'. Set when lines share a colour because colour carries something else — a group, say — so the stroke still tells them apart on paper, where no tooltip can. None draws a solid line.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineSeries.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineSeries.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable series identity within the chart (a CSS class hook and a client selection key), not display text.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineSeries.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineSeries.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Legend text, e.g. the subject's key.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LineSeries.points" class="doc doc-heading"> <code class="highlight language-python"><span class="n">points</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LineSeries.points" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The observations in time order. A bin the series has no study in carries no point, so the line breaks rather than interpolating a night that was never recorded.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ListedPublication" class="doc doc-heading"> <code>ListedPublication</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ListedPublication" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One publication on the listing.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="publication pydantic-field (yousleep_common.models.publications.ListedPublication.publication)" href="publications/#yousleep_common.models.publications.ListedPublication.publication">publication</a></code> (<code><a class="autorefs autorefs-internal" title="Publication pydantic-model (yousleep_common.models.analysis_config.Publication)" href="analysis_config/#yousleep_common.models.analysis_config.Publication">Publication</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="authorship pydantic-field (yousleep_common.models.publications.ListedPublication.authorship)" href="publications/#yousleep_common.models.publications.ListedPublication.authorship">authorship</a></code> (<code><span title="typing.Literal">Literal</span>['yousleep', 'developer', 'independent']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses pydantic-field (yousleep_common.models.publications.ListedPublication.analyses)" href="publications/#yousleep_common.models.publications.ListedPublication.analyses">analyses</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="PublicationAnalysis pydantic-model (yousleep_common.models.publications.PublicationAnalysis)" href="publications/#yousleep_common.models.publications.PublicationAnalysis">PublicationAnalysis</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="families pydantic-field (yousleep_common.models.publications.ListedPublication.families)" href="publications/#yousleep_common.models.publications.ListedPublication.families">families</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="note = None pydantic-field (yousleep_common.models.publications.ListedPublication.note)" href="publications/#yousleep_common.models.publications.ListedPublication.note">note</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ListedPublication.analyses" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ListedPublication.analyses" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analyses whose evidence includes it: those it evaluated as published, or describes. Empty when it is listed for another reason, which <code>note</code> gives.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ListedPublication.authorship" class="doc doc-heading"> <code class="highlight language-python"><span class="n">authorship</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ListedPublication.authorship" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Who wrote it, for the listing as a whole: 'yousleep' for work by the youSleep team, 'developer' for work by the developer of an analysis youSleep packages, 'independent' for anyone else's. A publication's own <code>by</code> is relative to one analysis's developer.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ListedPublication.families" class="doc doc-heading"> <code class="highlight language-python"><span class="n">families</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ListedPublication.families" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis families it concerns: those of the analyses it is evidence for, or those it is about when it is evidence for none.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ListedPublication.note" class="doc doc-heading"> <code class="highlight language-python"><span class="n">note</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ListedPublication.note" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How the publication relates to the analyses when it belongs to none of them, e.g. that it retrained the architecture rather than evaluating the published model.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ListedPublication.publication" class="doc doc-heading"> <code class="highlight language-python"><span class="n">publication</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ListedPublication.publication" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The publication.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalBin" class="doc doc-heading"> <code>LongitudinalBin</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalBin" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One time bin: a row slot every chart in the section shares.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.longitudinal.LongitudinalBin.key)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBin.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.longitudinal.LongitudinalBin.label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBin.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="n pydantic-field (yousleep_common.models.longitudinal.LongitudinalBin.n)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBin.n">n</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_count = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalBin.subject_count)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBin.subject_count">subject_count</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalBin.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalBin.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable bin identity within the section, e.g. '3' for night 3 or '2026-W12' for a calendar week.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalBin.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalBin.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Row label as drawn, e.g. 'Night 3' or 'Mar 2026'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalBin.n" class="doc doc-heading"> <code class="highlight language-python"><span class="n">n</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalBin.n" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies observed in this bin, across every group.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalBin.subject_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_count</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalBin.subject_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Distinct subjects behind <code>n</code> when any study in scope carries a subject key; None otherwise. Drawn beside <code>n</code> so attrition is readable in the figure.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalChart" class="doc doc-heading"> <code>LongitudinalChart</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One metric from one analysis configuration, across the bins.</p> <p>A metric several configurations produced yields one chart per configuration — the same shape the flat report gives a metric several configurations produced. A picker still lists the metric once; the charts under it are that metric from each source, each headed by the configuration that produced it, so no reader has to tell four pipelines apart inside one crowded figure.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.key)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="metric pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.metric)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.metric">metric</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit_label = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.unit_label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.unit_label">unit_label</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.analysis_config_id)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_parameters pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.analysis_parameters)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.analysis_parameters">analysis_parameters</a></code> (<code><span title="list">list</span>[<span title="tuple">tuple</span>[<span title="str">str</span>, <span title="str">str</span> | <span title="int">int</span> | <span title="float">float</span> | <span title="bool">bool</span>]]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="config_label pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.config_label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.config_label">config_label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="research_parameters = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.research_parameters)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.research_parameters">research_parameters</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="series pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.series)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.series">series</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalSeriesInfo pydantic-model (yousleep_common.models.longitudinal.LongitudinalSeriesInfo)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSeriesInfo">LongitudinalSeriesInfo</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="chart pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.chart)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.chart">chart</a></code> (<code><a class="autorefs autorefs-internal" title="BoxplotModel pydantic-model (yousleep_common.models.charts.BoxplotModel)" href="charts/#yousleep_common.models.charts.BoxplotModel">BoxplotModel</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="comparisons pydantic-field (yousleep_common.models.longitudinal.LongitudinalChart.comparisons)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart.comparisons">comparisons</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalComparison pydantic-model (yousleep_common.models.longitudinal.LongitudinalComparison)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison">LongitudinalComparison</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration whose output this chart draws.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.analysis_parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_parameters</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.analysis_parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis parameters used in computation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.chart" class="doc doc-heading"> <code class="highlight language-python"><span class="n">chart</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.chart" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The geometry: rows are bins in time order, one row per (bin, series), labelled with the bin and keyed with the series. A row below the section's <code>min_box_n</code> carries <code>points</code> instead of a box, and each row carries the studies and subjects behind it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.comparisons" class="doc doc-heading"> <code class="highlight language-python"><span class="n">comparisons</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.comparisons" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Descriptive comparisons between the chart's groups, per bin: each group against the first in legend order. Empty when the chart is not split, or where a bin holds too few observations on either side for a comparison to describe anything.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.config_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">config_label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.config_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the configuration, as the chart's heading — the parameters ride it when one configuration ran with more than one parameterisation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable chart identity within the section (safe as a render/caching key), one per metric and configuration.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the metric, e.g. 'N1 (%)'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.metric" class="doc doc-heading"> <code class="highlight language-python"><span class="n">metric</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.metric" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The metric drawn: a biomarker key or a <code>stats</code> dict key such as 'total-duration-ms'. Charts sharing a metric are the same quantity from different configurations.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.research_parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">research_parameters</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.research_parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Parameters outside the validated regime (exploratory output), same semantics as StatsOrigin.research_parameters.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.series" class="doc doc-heading"> <code class="highlight language-python"><span class="n">series</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.series" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The groups the chart's rows are split into, in legend order. Empty when the chart is not split — its rows then carry no series key, exactly as an ungrouped flat chart's rows do.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalChart.unit_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit_label</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalChart.unit_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display unit, e.g. 'min' or '%'.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalComparison" class="doc doc-heading"> <code>LongitudinalComparison</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>How one group's values in one bin sit against the reference group's.</p> <p>Descriptive only: a difference and an effect size, never a test, a p-value, or a verdict. Two groups measured in the same bin differ by some amount and overlap to some degree; what that means for a decision is the reader's to judge, with the study design in front of them.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="bin_key pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.bin_key)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.bin_key">bin_key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bin_label pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.bin_label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.bin_label">bin_label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reference pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.reference)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.reference">reference</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="group pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.group)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.group">group</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reference_n pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.reference_n)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.reference_n">reference_n</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="group_n pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.group_n)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.group_n">group_n</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="median_difference pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.median_difference)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.median_difference">median_difference</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="cliffs_delta pydantic-field (yousleep_common.models.longitudinal.LongitudinalComparison.cliffs_delta)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalComparison.cliffs_delta">cliffs_delta</a></code> (<code><span title="float">float</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.bin_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">bin_key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.bin_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The bin compared, keyed as the section's bins are.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.bin_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">bin_label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.bin_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display label of that bin.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.cliffs_delta" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cliffs_delta</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.cliffs_delta" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Cliff's delta over all pairs: how often a value from the group exceeds one from the reference, minus how often it falls below. 0 when the groups overlap evenly, 1 when every value is higher, -1 when every value is lower. Distribution-free, and no more than a description of the overlap.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.group" class="doc doc-heading"> <code class="highlight language-python"><span class="n">group</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.group" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The group being compared.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.group_n" class="doc doc-heading"> <code class="highlight language-python"><span class="n">group_n</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.group_n" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Observations behind the compared group in this bin.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.median_difference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">median_difference</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.median_difference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Group median minus reference median, in the chart's drawn unit — the axis unit, so it reads directly off the figure.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.reference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reference</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.reference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The group compared AGAINST — the first in legend order, the same one for every bin of the chart.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalComparison.reference_n" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reference_n</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalComparison.reference_n" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Observations behind the reference group in this bin.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalExclusion" class="doc doc-heading"> <code>LongitudinalExclusion</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalExclusion" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A subject or study the requested bins could not place, and why.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalExclusion.subject_key)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalExclusion.subject_key">subject_key</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_name = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalExclusion.study_name)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalExclusion.study_name">study_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.longitudinal.LongitudinalExclusion.reason)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalExclusion.reason">reason</a></code> (<code><span title="str">str</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.longitudinal.LongitudinalExclusion._names_something">_names_something</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalExclusion.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalExclusion.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Human-readable reason, ready to print.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalExclusion.study_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalExclusion.study_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The excluded study, when a single study is left out: a keyless study under declared positions, or a study whose recording carries no known start date under calendar bins.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalExclusion.subject_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalExclusion.subject_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The excluded subject, when a whole subject is left out: one that declares no session index while others do, one that declares it on only some of its studies, or one whose recording order cannot be derived.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalSection" class="doc doc-heading"> <code>LongitudinalSection</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The longitudinal half of a project report.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="basis pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.basis)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.basis">basis</a></code> (<code><a class="autorefs autorefs-internal" title="LongitudinalBasis = Literal['session-index', 'calendar'] module-attribute (yousleep_common.models.longitudinal.LongitudinalBasis)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBasis">LongitudinalBasis</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="regime = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.regime)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.regime">regime</a></code> (<code><a class="autorefs autorefs-internal" title="LongitudinalRegime = Literal['derived', 'declared'] module-attribute (yousleep_common.models.longitudinal.LongitudinalRegime)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalRegime">LongitudinalRegime</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="granularity = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.granularity)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.granularity">granularity</a></code> (<code><a class="autorefs autorefs-internal" title="CalendarGranularity = Literal['day', 'week', 'month'] module-attribute (yousleep_common.models.longitudinal.CalendarGranularity)" href="longitudinal/#yousleep_common.models.longitudinal.CalendarGranularity">CalendarGranularity</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="min_box_n pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.min_box_n)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.min_box_n">min_box_n</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bins pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.bins)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.bins">bins</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalBin pydantic-model (yousleep_common.models.longitudinal.LongitudinalBin)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBin">LongitudinalBin</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="charts pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.charts)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.charts">charts</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalChart pydantic-model (yousleep_common.models.longitudinal.LongitudinalChart)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalChart">LongitudinalChart</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="excluded pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.excluded)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.excluded">excluded</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalExclusion pydantic-model (yousleep_common.models.longitudinal.LongitudinalExclusion)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalExclusion">LongitudinalExclusion</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_view = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSection.subject_view)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection.subject_view">subject_view</a></code> (<code><a class="autorefs autorefs-internal" title="LongitudinalSubjectView pydantic-model (yousleep_common.models.longitudinal.LongitudinalSubjectView)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectView">LongitudinalSubjectView</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.basis" class="doc doc-heading"> <code class="highlight language-python"><span class="n">basis</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.basis" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the bins are.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.bins" class="doc doc-heading"> <code class="highlight language-python"><span class="n">bins</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.bins" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The bins in time order; every chart's rows follow them.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.charts" class="doc doc-heading"> <code class="highlight language-python"><span class="n">charts</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.charts" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>One chart per rendered metric and analysis configuration, in display order: metrics in their display order, and within a metric the configurations in the order the report lists them.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.excluded" class="doc doc-heading"> <code class="highlight language-python"><span class="n">excluded</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.excluded" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Subjects and studies the bins could not place — named explicitly, mirrored in the report's warnings.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.granularity" class="doc doc-heading"> <code class="highlight language-python"><span class="n">granularity</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.granularity" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>On a calendar section: the span of one bin. None on a session-index section.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.min_box_n" class="doc doc-heading"> <code class="highlight language-python"><span class="n">min_box_n</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.min_box_n" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A row with fewer observations than this is drawn as points, not a box — configured on the server.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.regime" class="doc doc-heading"> <code class="highlight language-python"><span class="n">regime</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.regime" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>On a session-index section: 'declared' when any subject in scope declares a session index (only fully declared subjects are drawn), 'derived' otherwise (positions follow recording order; a keyless study is its own single-session subject in bin 1). None on a calendar section.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSection.subject_view" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_view</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSection.subject_view" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set when the request selected subjects: the same metrics and configurations drawn as one line per person, over the same bins. None when none were selected.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalSeriesInfo" class="doc doc-heading"> <code>LongitudinalSeriesInfo</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalSeriesInfo" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One legended series in a longitudinal chart: a group, or the whole cohort.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.longitudinal.LongitudinalSeriesInfo.key)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSeriesInfo.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.longitudinal.LongitudinalSeriesInfo.label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSeriesInfo.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="group = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSeriesInfo.group)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSeriesInfo.group">group</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="color_token = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSeriesInfo.color_token)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSeriesInfo.color_token">color_token</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSeriesInfo.color_token" class="doc doc-heading"> <code class="highlight language-python"><span class="n">color_token</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSeriesInfo.color_token" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Brand color token NAME the series' boxes use, matching the rows' <code>color_token</code>.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSeriesInfo.group" class="doc doc-heading"> <code class="highlight language-python"><span class="n">group</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSeriesInfo.group" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The tag group or stratum this series draws; None on an unsplit chart, whose single series is the whole cohort.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSeriesInfo.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSeriesInfo.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The value stamped on the chart's rows as <code>series_key</code>; a client selection key, not display text.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSeriesInfo.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSeriesInfo.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Legend text: the group's name, or the cohort's when the chart is not split.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalSubjectChart" class="doc doc-heading"> <code>LongitudinalSubjectChart</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One metric from one analysis configuration, per subject over time.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.key)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="metric pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.metric)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.metric">metric</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit_label = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.unit_label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.unit_label">unit_label</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.analysis_config_id)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="config_label pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.config_label)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.config_label">config_label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="research_parameters = None pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.research_parameters)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.research_parameters">research_parameters</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="chart pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectChart.chart)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart.chart">chart</a></code> (<code><a class="autorefs autorefs-internal" title="LineChartModel pydantic-model (yousleep_common.models.charts.LineChartModel)" href="charts/#yousleep_common.models.charts.LineChartModel">LineChartModel</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration whose output this chart draws.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.chart" class="doc doc-heading"> <code class="highlight language-python"><span class="n">chart</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.chart" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The geometry: one line per selected subject over the section's bins.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.config_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">config_label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.config_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the configuration, as the chart's heading.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable chart identity within the view, one per metric and configuration.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the metric, e.g. 'TST'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.metric" class="doc doc-heading"> <code class="highlight language-python"><span class="n">metric</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.metric" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The metric drawn.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.research_parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">research_parameters</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.research_parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Parameters outside the validated regime (exploratory output), same semantics as StatsOrigin.research_parameters.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectChart.unit_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit_label</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectChart.unit_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display unit, e.g. 'min' or '%'.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.LongitudinalSubjectView" class="doc doc-heading"> <code>LongitudinalSubjectView</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectView" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The selected subjects, drawn one line each.</p> <p>Boxes answer what a cohort did; a line answers what one person did. Selection is explicit and capped, because a figure with more lines than distinguishable colours shows nothing: past the cap the view comes back empty and the report says how many were asked for.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="subjects pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectView.subjects)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectView.subjects">subjects</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_subjects pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectView.max_subjects)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectView.max_subjects">max_subjects</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="charts pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectView.charts)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectView.charts">charts</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalSubjectChart pydantic-model (yousleep_common.models.longitudinal.LongitudinalSubjectChart)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectChart">LongitudinalSubjectChart</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="excluded pydantic-field (yousleep_common.models.longitudinal.LongitudinalSubjectView.excluded)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSubjectView.excluded">excluded</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="LongitudinalExclusion pydantic-model (yousleep_common.models.longitudinal.LongitudinalExclusion)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalExclusion">LongitudinalExclusion</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectView.charts" class="doc doc-heading"> <code class="highlight language-python"><span class="n">charts</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectView.charts" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>One chart per metric and analysis configuration, in the same order as the section's boxplots.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectView.excluded" class="doc doc-heading"> <code class="highlight language-python"><span class="n">excluded</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectView.excluded" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Selected subjects the view could not draw — a key that matches no study in scope, or one whose studies the bins exclude.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectView.max_subjects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_subjects</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectView.max_subjects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The most lines one figure draws — the number of distinguishable series colours the design system has.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.LongitudinalSubjectView.subjects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subjects</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.LongitudinalSubjectView.subjects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The subject keys drawn, in legend order, as entered.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestAnalysis" class="doc doc-heading"> <code>ManifestAnalysis</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestAnalysis" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Which analysis and configuration this run is, for provenance.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id = None pydantic-field (yousleep_common.models.analysis_manifest.ManifestAnalysis.id)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestAnalysis.id">id</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="config_id pydantic-field (yousleep_common.models.analysis_manifest.ManifestAnalysis.config_id)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestAnalysis.config_id">config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="config_sha1 = None pydantic-field (yousleep_common.models.analysis_manifest.ManifestAnalysis.config_sha1)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestAnalysis.config_sha1">config_sha1</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestAnalysis.config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestAnalysis.config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The configuration id, e.g. u-sleep-research-v2.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestAnalysis.config_sha1" class="doc doc-heading"> <code class="highlight language-python"><span class="n">config_sha1</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestAnalysis.config_sha1" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The registered configuration's content hash.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestAnalysis.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestAnalysis.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis id on the platform; None for a hand run.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestInputs" class="doc doc-heading"> <code>ManifestInputs</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestInputs" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Everything the container reads.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestInputs.recording">recording</span></code> (<code><a class="autorefs autorefs-internal" title="ManifestRecording pydantic-model (yousleep_common.models.analysis_manifest.ManifestRecording)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestRecording">ManifestRecording</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="events = None pydantic-field (yousleep_common.models.analysis_manifest.ManifestInputs.events)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestInputs.events">events</a></code> (<code><a class="autorefs autorefs-internal" title="FileInput pydantic-model (yousleep_common.models.analysis_manifest.FileInput)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.FileInput">FileInput</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestInputs.metadata">metadata</span></code> (<code><a class="autorefs autorefs-internal" title="ManifestMetadata pydantic-model (yousleep_common.models.analysis_manifest.ManifestMetadata)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestMetadata">ManifestMetadata</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestInputs.events" class="doc doc-heading"> <code class="highlight language-python"><span class="n">events</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestInputs.events" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Upstream events document, when the configuration declares event inputs.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestMetadata" class="doc doc-heading"> <code>ManifestMetadata</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestMetadata" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Inline context an analysis may use; absent when the configuration declares no metadata input.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestMetadata.subject">subject</span></code> (<code><a class="autorefs autorefs-internal" title="ManifestSubject pydantic-model (yousleep_common.models.analysis_manifest.ManifestSubject)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestSubject">ManifestSubject</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestMetadata.study">study</span></code> (<code><a class="autorefs autorefs-internal" title="ManifestStudy pydantic-model (yousleep_common.models.analysis_manifest.ManifestStudy)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestStudy">ManifestStudy</a> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestOutputs" class="doc doc-heading"> <code>ManifestOutputs</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestOutputs" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Where the container must write.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="events pydantic-field (yousleep_common.models.analysis_manifest.ManifestOutputs.events)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestOutputs.events">events</a></code> (<code><a class="autorefs autorefs-internal" title="FileInput pydantic-model (yousleep_common.models.analysis_manifest.FileInput)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.FileInput">FileInput</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestOutputs.events" class="doc doc-heading"> <code class="highlight language-python"><span class="n">events</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestOutputs.events" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The events document (see the events output format).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestRecording" class="doc doc-heading"> <code>ManifestRecording</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestRecording" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The recording the analysis reads, with the channels selected for it.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="path pydantic-field (yousleep_common.models.analysis_manifest.ManifestRecording.path)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestRecording.path">path</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestRecording.format">format</span></code> (<code><span title="typing.Literal">Literal</span>['edf']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="start = None pydantic-field (yousleep_common.models.analysis_manifest.ManifestRecording.start)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestRecording.start">start</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestRecording.duration_ms">duration_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channels pydantic-field (yousleep_common.models.analysis_manifest.ManifestRecording.channels)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestRecording.channels">channels</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelRef pydantic-model (yousleep_common.models.analysis_manifest.ChannelRef)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ChannelRef">ChannelRef</a>]</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestRecording._inside_the_container">_inside_the_container</span></code> → <code><a class="autorefs autorefs-internal" title="path pydantic-field (yousleep_common.models.analysis_manifest.ManifestRecording.path)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestRecording.path">path</a></code> </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestRecording._unique_indices">_unique_indices</span></code> → <code><a class="autorefs autorefs-internal" title="channels pydantic-field (yousleep_common.models.analysis_manifest.ManifestRecording.channels)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestRecording.channels">channels</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestRecording.channels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channels</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestRecording.channels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The channels selected for this run.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestRecording.path" class="doc doc-heading"> <code class="highlight language-python"><span class="n">path</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestRecording.path" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Path of the recording file as the container sees it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestRecording.start" class="doc doc-heading"> <code class="highlight language-python"><span class="n">start</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestRecording.start" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The recording's start as written in its header, a wall clock, not an instant.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestResources" class="doc doc-heading"> <code>ManifestResources</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestResources" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What the run has been given. The cgroup enforces the memory; the container sizes its pools to the cores.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="cpus pydantic-field (yousleep_common.models.analysis_manifest.ManifestResources.cpus)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestResources.cpus">cpus</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="memory_mib pydantic-field (yousleep_common.models.analysis_manifest.ManifestResources.memory_mib)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.ManifestResources.memory_mib">memory_mib</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestResources.gpus">gpus</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestResources.gpu_devices">gpu_devices</span></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestResources.gpu_memory_mib">gpu_memory_mib</span></code> (<code><span title="list">list</span>[<span title="pydantic.PositiveInt">PositiveInt</span>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestResources.cpus" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cpus</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestResources.cpus" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whole cores reserved for the run; size thread pools to this.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ManifestResources.memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">memory_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ManifestResources.memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>System memory in MiB; exceeding it is an OOM kill.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestStudy" class="doc doc-heading"> <code>ManifestStudy</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestStudy" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Study-level markers, as milliseconds from the recording start.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestStudy.lights_off_ms">lights_off_ms</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestStudy.lights_on_ms">lights_on_ms</span></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ManifestSubject" class="doc doc-heading"> <code>ManifestSubject</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ManifestSubject" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What the platform knows about the subject, for analyses that use it.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestSubject.age">age</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestSubject.sex">sex</span></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.metadata.Sex)" href="../types/metadata/#yousleep_common.types.metadata.Sex">Sex</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.ManifestSubject.bmi">bmi</span></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.MemberOut" class="doc doc-heading"> <code>MemberOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.MemberOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A member of an organization, as listed to its other members.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.membership.MemberOut.id)" href="membership/#yousleep_common.models.membership.MemberOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="user_id pydantic-field (yousleep_common.models.membership.MemberOut.user_id)" href="membership/#yousleep_common.models.membership.MemberOut.user_id">user_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.membership.MemberOut.email)" href="membership/#yousleep_common.models.membership.MemberOut.email">email</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.membership.MemberOut.name)" href="membership/#yousleep_common.models.membership.MemberOut.name">name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.membership.MemberOut.role)" href="membership/#yousleep_common.models.membership.MemberOut.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.MembershipRole)" href="../types/#yousleep_common.types.MembershipRole">MembershipRole</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.membership.MemberOut.created_at)" href="membership/#yousleep_common.models.membership.MemberOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the member joined.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberOut.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberOut.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's email address.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The membership id; the id to address for role changes and removal.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberOut.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberOut.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's display name, if set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberOut.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberOut.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's role in the organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberOut.user_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">user_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberOut.user_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's user id.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.MemberRoleUpdate" class="doc doc-heading"> <code>MemberRoleUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.MemberRoleUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Change a member's role between admin and member.</p> <p>Ownership is not a role to assign; it moves through an ownership transfer, which requires the owner's password.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.membership.MemberRoleUpdate.role)" href="membership/#yousleep_common.models.membership.MemberRoleUpdate.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.MembershipRole)" href="../types/#yousleep_common.types.MembershipRole">MembershipRole</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.membership.MemberRoleUpdate._not_owner">_not_owner</span></code> → <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.membership.MemberRoleUpdate.role)" href="membership/#yousleep_common.models.membership.MemberRoleUpdate.role">role</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberRoleUpdate.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberRoleUpdate.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's new role: admin or member.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.MemberUsageOut" class="doc doc-heading"> <code>MemberUsageOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One member's share of the organization's usage.</p> <p>Read by the organization's owner and admins, who pay for what every member holds but cannot open a colleague's private projects: the figures say where the space and the credits go without naming what is in them.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="user_id pydantic-field (yousleep_common.models.organization.MemberUsageOut.user_id)" href="organization/#yousleep_common.models.organization.MemberUsageOut.user_id">user_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.organization.MemberUsageOut.email)" href="organization/#yousleep_common.models.organization.MemberUsageOut.email">email</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.organization.MemberUsageOut.name)" href="organization/#yousleep_common.models.organization.MemberUsageOut.name">name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.organization.MemberUsageOut.role)" href="organization/#yousleep_common.models.organization.MemberUsageOut.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.organization.MembershipRole)" href="../types/organization/#yousleep_common.types.organization.MembershipRole">MembershipRole</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_bytes pydantic-field (yousleep_common.models.organization.MemberUsageOut.storage_bytes)" href="organization/#yousleep_common.models.organization.MemberUsageOut.storage_bytes">storage_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="private_storage_bytes pydantic-field (yousleep_common.models.organization.MemberUsageOut.private_storage_bytes)" href="organization/#yousleep_common.models.organization.MemberUsageOut.private_storage_bytes">private_storage_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_count pydantic-field (yousleep_common.models.organization.MemberUsageOut.project_count)" href="organization/#yousleep_common.models.organization.MemberUsageOut.project_count">project_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_count pydantic-field (yousleep_common.models.organization.MemberUsageOut.analysis_count)" href="organization/#yousleep_common.models.organization.MemberUsageOut.analysis_count">analysis_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="credits_used pydantic-field (yousleep_common.models.organization.MemberUsageOut.credits_used)" href="organization/#yousleep_common.models.organization.MemberUsageOut.credits_used">credits_used</a></code> (<code><span title="float">float</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.analysis_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.analysis_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's analyses that are neither deleted nor failed, cancelled or rejected.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.credits_used" class="doc doc-heading"> <code class="highlight language-python"><span class="n">credits_used</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.credits_used" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits the organization has spent or reserved on those analyses.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's email address.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's display name, if set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.private_storage_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">private_storage_bytes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.private_storage_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The part of <code>storage_bytes</code> inside the member's private projects, which only they can open or free.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.project_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.project_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Projects the member owns in the organization, private ones included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's role in the organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.storage_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_bytes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.storage_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Bytes the member's recordings, results and exports hold against the organization's storage ceiling, private projects included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.MemberUsageOut.user_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">user_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.MemberUsageOut.user_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's user id.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Membership" class="doc doc-heading"> <code>Membership</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Membership" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Canonical Membership model — a user's role within an organization.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.membership.Membership.id)" href="membership/#yousleep_common.models.membership.Membership.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="org_id pydantic-field (yousleep_common.models.membership.Membership.org_id)" href="membership/#yousleep_common.models.membership.Membership.org_id">org_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="user_id pydantic-field (yousleep_common.models.membership.Membership.user_id)" href="membership/#yousleep_common.models.membership.Membership.user_id">user_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.membership.Membership.role)" href="membership/#yousleep_common.models.membership.Membership.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.MembershipRole)" href="../types/#yousleep_common.types.MembershipRole">MembershipRole</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.membership.Membership.created_at)" href="membership/#yousleep_common.models.membership.Membership.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Membership.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Membership.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Creation timestamp</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Membership.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Membership.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the membership</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Membership.org_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">org_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Membership.org_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization the user belongs to</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Membership.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Membership.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member's role in the organization</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Membership.user_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">user_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Membership.user_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member user</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.MessageResponse" class="doc doc-heading"> <code>MessageResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.MessageResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Response model for a generic, str message response.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.base_models.MessageResponse.message">message</span></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.NamedEntityCreate" class="doc doc-heading"> <code>NamedEntityCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.NamedEntityCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.base_models._NamedEntityFields">_NamedEntityFields</span></code></p> <p>Create payload for named entities.</p> <p><code>name</code> is required. <code>tags</code> and <code>description</code> default to None.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.base_models.NamedEntityCreate.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.base_models.NamedEntityCreate.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.base_models.NamedEntityCreate.name)" href="base_models/#yousleep_common.models.base_models.NamedEntityCreate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.NamedEntityCreate.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.NamedEntityCreate.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The name of the entity.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.NamedEntityUpdate" class="doc doc-heading"> <code>NamedEntityUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.NamedEntityUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.base_models._NamedEntityFields">_NamedEntityFields</span></code></p> <p>PATCH payload for named entities.</p> <p>Universal field semantics:</p> <ul> <li><strong>Omit a field</strong> to leave it unchanged.</li> <li><strong>Include a field with a value</strong> to update it.</li> <li><strong>Include a field with <code>null</code></strong> to clear it (where the field is nullable in storage — e.g. <code>description</code>, <code>tags</code>).</li> </ul> <p><code>name</code> is the exception: it is required in storage and cannot be cleared. Sending <code>{"name": null}</code> is rejected with 422 — omit the field if you don't want to change it.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.base_models.NamedEntityUpdate.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.base_models.NamedEntityUpdate.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.base_models.NamedEntityUpdate.name)" href="base_models/#yousleep_common.models.base_models.NamedEntityUpdate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.NamedEntityUpdate.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.NamedEntityUpdate.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>New name for the entity. Omit to leave unchanged. Cannot be null.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.NamedEntityUpdate.name_cannot_be_explicit_null" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name_cannot_be_explicit_null</span><span class="p">()</span></code> <a href="#yousleep_common.models.NamedEntityUpdate.name_cannot_be_explicit_null" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Reject <code>{"name": null}</code> while still allowing <code>name</code> to be omitted.</p> <p>Sending an explicit null is rejected because <code>name</code> is required in storage; clearing it would leave the entity in an invalid state. Omit the field if you don't want to change it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.OrgCredits" class="doc doc-heading"> <code>OrgCredits</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.OrgCredits" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An organization's credits: research grants and purchased credits.</p> <p>The two never mix. Research analyses are paid from <code>grants</code>; commercial analyses and storage above the free ceiling from <code>purchased</code>.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="grants pydantic-field (yousleep_common.models.credit.OrgCredits.grants)" href="credit/#yousleep_common.models.credit.OrgCredits.grants">grants</a></code> (<code><a class="autorefs autorefs-internal" title="WalletBalance pydantic-model (yousleep_common.models.credit.WalletBalance)" href="credit/#yousleep_common.models.credit.WalletBalance">WalletBalance</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="purchased pydantic-field (yousleep_common.models.credit.OrgCredits.purchased)" href="credit/#yousleep_common.models.credit.OrgCredits.purchased">purchased</a></code> (<code><a class="autorefs autorefs-internal" title="WalletBalance pydantic-model (yousleep_common.models.credit.WalletBalance)" href="credit/#yousleep_common.models.credit.WalletBalance">WalletBalance</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrgCredits.grants" class="doc doc-heading"> <code class="highlight language-python"><span class="n">grants</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrgCredits.grants" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits granted for research analyses, across every grant.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrgCredits.purchased" class="doc doc-heading"> <code class="highlight language-python"><span class="n">purchased</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrgCredits.purchased" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits bought, for commercial analyses and for storage above the free ceiling. They never expire.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Organization" class="doc doc-heading"> <code>Organization</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Organization" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Canonical Organization model — the billing/quota/tenancy boundary.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.organization.Organization.id)" href="organization/#yousleep_common.models.organization.Organization.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.organization.Organization.name)" href="organization/#yousleep_common.models.organization.Organization.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_ceiling_gb = None pydantic-field (yousleep_common.models.organization.Organization.storage_ceiling_gb)" href="organization/#yousleep_common.models.organization.Organization.storage_ceiling_gb">storage_ceiling_gb</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="seat_limit = None pydantic-field (yousleep_common.models.organization.Organization.seat_limit)" href="organization/#yousleep_common.models.organization.Organization.seat_limit">seat_limit</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_limit = None pydantic-field (yousleep_common.models.organization.Organization.study_limit)" href="organization/#yousleep_common.models.organization.Organization.study_limit">study_limit</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_limit = None pydantic-field (yousleep_common.models.organization.Organization.project_limit)" href="organization/#yousleep_common.models.organization.Organization.project_limit">project_limit</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_insolvent_since = None pydantic-field (yousleep_common.models.organization.Organization.storage_insolvent_since)" href="organization/#yousleep_common.models.organization.Organization.storage_insolvent_since">storage_insolvent_since</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="platform_operated = False pydantic-field (yousleep_common.models.organization.Organization.platform_operated)" href="organization/#yousleep_common.models.organization.Organization.platform_operated">platform_operated</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses_at_site = False pydantic-field (yousleep_common.models.organization.Organization.analyses_at_site)" href="organization/#yousleep_common.models.organization.Organization.analyses_at_site">analyses_at_site</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recordings_at_site = False pydantic-field (yousleep_common.models.organization.Organization.recordings_at_site)" href="organization/#yousleep_common.models.organization.Organization.recordings_at_site">recordings_at_site</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="site_compute_factor = None pydantic-field (yousleep_common.models.organization.Organization.site_compute_factor)" href="organization/#yousleep_common.models.organization.Organization.site_compute_factor">site_compute_factor</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.organization.Organization.created_at)" href="organization/#yousleep_common.models.organization.Organization.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="deleted_at = None pydantic-field (yousleep_common.models.organization.Organization.deleted_at)" href="organization/#yousleep_common.models.organization.Organization.deleted_at">deleted_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.analyses_at_site" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses_at_site</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.analyses_at_site" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the organisation's analyses run at its site, on its own runners, instead of on the platform. Set by a platform administrator while the organisation holds site compute.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Creation timestamp</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.deleted_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">deleted_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.deleted_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Soft-delete timestamp, if deleted</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the organization</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the organization</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.platform_operated" class="doc doc-heading"> <code class="highlight language-python"><span class="n">platform_operated</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.platform_operated" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the platform operates the organisation itself, as for a demonstration site.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.project_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_limit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.project_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-org override of how many projects the organization may hold. Null = the configured default. Admin-set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.recordings_at_site" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recordings_at_site</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.recordings_at_site" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the organisation's new projects keep their recordings in its own bucket. Set by a platform administrator while the organisation holds site storage; a project keeps where it is stored.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.seat_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">seat_limit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.seat_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-org override of how many members plus pending invitations the organization may hold. Null = the configured default. Admin-set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.site_compute_factor" class="doc doc-heading"> <code class="highlight language-python"><span class="n">site_compute_factor</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.site_compute_factor" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organisation's own factor on the platform price for analyses run at its site. Null = the platform's factor. Admin-set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.storage_ceiling_gb" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_ceiling_gb</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.storage_ceiling_gb" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-org storage-ceiling override (GB). Null = the configured default ceiling. Admin-set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.storage_insolvent_since" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_insolvent_since</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.storage_insolvent_since" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the org's balance stopped covering its daily storage debit (start of the grace window). Null = solvent. Stored data is purged after the configured grace period.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Organization.study_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_limit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Organization.study_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-org override of how many studies one project may hold. Null = the configured default.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.OrganizationCapabilities" class="doc doc-heading"> <code>OrganizationCapabilities</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.OrganizationCapabilities" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An organisation's capabilities on its own hardware, and the agreement they rest on.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="platform_operated pydantic-field (yousleep_common.models.site_capabilities.OrganizationCapabilities.platform_operated)" href="site_capabilities/#yousleep_common.models.site_capabilities.OrganizationCapabilities.platform_operated">platform_operated</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="site_agreement_version pydantic-field (yousleep_common.models.site_capabilities.OrganizationCapabilities.site_agreement_version)" href="site_capabilities/#yousleep_common.models.site_capabilities.OrganizationCapabilities.site_agreement_version">site_agreement_version</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="acceptance = None pydantic-field (yousleep_common.models.site_capabilities.OrganizationCapabilities.acceptance)" href="site_capabilities/#yousleep_common.models.site_capabilities.OrganizationCapabilities.acceptance">acceptance</a></code> (<code><a class="autorefs autorefs-internal" title="SiteAgreementAcceptance pydantic-model (yousleep_common.models.site_capabilities.SiteAgreementAcceptance)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteAgreementAcceptance">SiteAgreementAcceptance</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="capabilities pydantic-field (yousleep_common.models.site_capabilities.OrganizationCapabilities.capabilities)" href="site_capabilities/#yousleep_common.models.site_capabilities.OrganizationCapabilities.capabilities">capabilities</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CapabilityStatus pydantic-model (yousleep_common.models.site_capabilities.CapabilityStatus)" href="site_capabilities/#yousleep_common.models.site_capabilities.CapabilityStatus">CapabilityStatus</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationCapabilities.acceptance" class="doc doc-heading"> <code class="highlight language-python"><span class="n">acceptance</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationCapabilities.acceptance" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organisation's latest acceptance of the site agreement.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationCapabilities.capabilities" class="doc doc-heading"> <code class="highlight language-python"><span class="n">capabilities</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationCapabilities.capabilities" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Each capability's state, one entry per capability.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationCapabilities.platform_operated" class="doc doc-heading"> <code class="highlight language-python"><span class="n">platform_operated</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationCapabilities.platform_operated" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the platform operates the organisation itself; such an organisation needs no acceptance of the site agreement.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationCapabilities.site_agreement_version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">site_agreement_version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationCapabilities.site_agreement_version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The latest published version of the site agreement; None while none is published, when nothing can be accepted.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.OrganizationUpdate" class="doc doc-heading"> <code>OrganizationUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.OrganizationUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Self-service organization update: the display name (owner or admin).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.organization.OrganizationUpdate.name)" href="organization/#yousleep_common.models.organization.OrganizationUpdate.name">name</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationUpdate.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationUpdate.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>New display name for the organization: a team label of at most 64 characters, shown wherever the organization is named (member list, dialogs, emails).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.OrganizationUsageOut" class="doc doc-heading"> <code>OrganizationUsageOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.OrganizationUsageOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The organization's usage against its ceilings, member by member.</p> <p>The owner's and admins' answer to "what fills the storage": the same totals every member sees on the account page, then one row per member, largest holder first. Private projects count, because the organization pays for them; their names and contents do not appear here.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="storage_bytes pydantic-field (yousleep_common.models.organization.OrganizationUsageOut.storage_bytes)" href="organization/#yousleep_common.models.organization.OrganizationUsageOut.storage_bytes">storage_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_ceiling_bytes pydantic-field (yousleep_common.models.organization.OrganizationUsageOut.storage_ceiling_bytes)" href="organization/#yousleep_common.models.organization.OrganizationUsageOut.storage_ceiling_bytes">storage_ceiling_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_count pydantic-field (yousleep_common.models.organization.OrganizationUsageOut.project_count)" href="organization/#yousleep_common.models.organization.OrganizationUsageOut.project_count">project_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_cap = None pydantic-field (yousleep_common.models.organization.OrganizationUsageOut.project_cap)" href="organization/#yousleep_common.models.organization.OrganizationUsageOut.project_cap">project_cap</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="members pydantic-field (yousleep_common.models.organization.OrganizationUsageOut.members)" href="organization/#yousleep_common.models.organization.OrganizationUsageOut.members">members</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="MemberUsageOut pydantic-model (yousleep_common.models.organization.MemberUsageOut)" href="organization/#yousleep_common.models.organization.MemberUsageOut">MemberUsageOut</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationUsageOut.members" class="doc doc-heading"> <code class="highlight language-python"><span class="n">members</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationUsageOut.members" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>One row per member, the largest storage holder first; ties keep the members' order (owner, admins, then by joining date).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationUsageOut.project_cap" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_cap</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationUsageOut.project_cap" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Projects the organization may hold; null when uncapped.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationUsageOut.project_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationUsageOut.project_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Projects in the organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationUsageOut.storage_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_bytes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationUsageOut.storage_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Bytes the organization holds against its storage ceiling.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OrganizationUsageOut.storage_ceiling_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_ceiling_bytes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OrganizationUsageOut.storage_ceiling_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization's storage ceiling, in bytes.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Outputs" class="doc doc-heading"> <code>Outputs</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Outputs" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Defines the output of the analysis.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="supports_full_probabilistic_output = False pydantic-field (yousleep_common.models.analysis_config.io_models.Outputs.supports_full_probabilistic_output)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Outputs.supports_full_probabilistic_output">supports_full_probabilistic_output</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="events pydantic-field (yousleep_common.models.analysis_config.io_models.Outputs.events)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Outputs.events">events</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="EventType pydantic-model (yousleep_common.models.events.EventType)" href="events/#yousleep_common.models.events.EventType">EventType</a>]</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_probabilistic_consistency() pydantic-validator (yousleep_common.models.analysis_config.io_models.Outputs.validate_probabilistic_consistency)" href="analysis_config/io_models/#yousleep_common.models.analysis_config.io_models.Outputs.validate_probabilistic_consistency">validate_probabilistic_consistency</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Outputs.events" class="doc doc-heading"> <code class="highlight language-python"><span class="n">events</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Outputs.events" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The list of typed event that the analysis outputs.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Outputs.supports_full_probabilistic_output" class="doc doc-heading"> <code class="highlight language-python"><span class="n">supports_full_probabilistic_output</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Outputs.supports_full_probabilistic_output" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the analysis supports outputting full probabilistic distributions (all class probabilities per prediction, not just argmax). When true, users can request overlapping events with probability scores for all classes.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Outputs.validate_probabilistic_consistency" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_probabilistic_consistency</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.Outputs.validate_probabilistic_consistency" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate probabilistic output consistency.</p> <p>If supports_full_probabilistic_output is True, all event types must be probabilistic.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.OwnershipTransfer" class="doc doc-heading"> <code>OwnershipTransfer</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.OwnershipTransfer" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Hand the organization to another member (owner only).</p> <p>The current owner becomes an admin. The password is re-entered because the transfer hands over every project, member and credit of the organization in one step.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="user_id pydantic-field (yousleep_common.models.organization.OwnershipTransfer.user_id)" href="organization/#yousleep_common.models.organization.OwnershipTransfer.user_id">user_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="password pydantic-field (yousleep_common.models.organization.OwnershipTransfer.password)" href="organization/#yousleep_common.models.organization.OwnershipTransfer.password">password</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OwnershipTransfer.password" class="doc doc-heading"> <code class="highlight language-python"><span class="n">password</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OwnershipTransfer.password" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The caller's current password, re-entered to confirm.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.OwnershipTransfer.user_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">user_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.OwnershipTransfer.user_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member who becomes the owner.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PaginatedRecordingsResponse" class="doc doc-heading"> <code>PaginatedRecordingsResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PaginatedRecordingsResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>Paginated list of recordings.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.recording.PaginatedRecordingsResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.recording.PaginatedRecordingsResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.recording.PaginatedRecordingsResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.recording.PaginatedRecordingsResponse.recordings">recordings</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="RecordingOut pydantic-model (yousleep_common.models.recording.RecordingOut)" href="recording/#yousleep_common.models.recording.RecordingOut">RecordingOut</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PaginatedResponse" class="doc doc-heading"> <code>PaginatedResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PaginatedResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Base fields for a paginated listing response.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.pagination.PaginatedResponse.total)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.pagination.PaginatedResponse.offset)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.pagination.PaginatedResponse.limit)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PaginatedResponse.limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">limit</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PaginatedResponse.limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Maximum items in this page.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PaginatedResponse.offset" class="doc doc-heading"> <code class="highlight language-python"><span class="n">offset</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PaginatedResponse.offset" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Offset this page was read at.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PaginatedResponse.total" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PaginatedResponse.total" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total items matching the query, across all pages.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Parameters" class="doc doc-heading"> <code>Parameters</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Parameters" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The analysis-specific parameters a configuration declares.</p> <p>Every parameter reaches the container through the analysis manifest, keyed by its <code>key</code> and typed as declared here; the platform passes nothing else.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="custom pydantic-field (yousleep_common.models.analysis_config.parameters.Parameters.custom)" href="analysis_config/parameters/#yousleep_common.models.analysis_config.parameters.Parameters.custom">custom</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AnalysisParameter pydantic-model (yousleep_common.models.analysis_config.parameters.AnalysisParameter)" href="analysis_config/parameters/#yousleep_common.models.analysis_config.parameters.AnalysisParameter">AnalysisParameter</a>]</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_unique_keys(custom) pydantic-validator (yousleep_common.models.analysis_config.parameters.Parameters.validate_unique_keys)" href="analysis_config/parameters/#yousleep_common.models.analysis_config.parameters.Parameters.validate_unique_keys">validate_unique_keys</a></code> → <code><a class="autorefs autorefs-internal" title="custom pydantic-field (yousleep_common.models.analysis_config.parameters.Parameters.custom)" href="analysis_config/parameters/#yousleep_common.models.analysis_config.parameters.Parameters.custom">custom</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Parameters.custom" class="doc doc-heading"> <code class="highlight language-python"><span class="n">custom</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Parameters.custom" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Parameters the analysis accepts. Empty when it takes none.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Parameters.research_parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">research_parameters</span><span class="p">(</span><span class="n">submitted</span><span class="p">)</span></code> <a href="#yousleep_common.models.Parameters.research_parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the API names of parameters whose effective value is research mode.</p> <p>The effective value of each custom parameter is the submitted value (matched on :attr:<code>AnalysisParameter.api_name</code>) or, when absent, the parameter's default — a default can itself lie outside the validated regime. Parameters of configurations that declare no validated regime never appear.</p> <p><span class="doc-section-title">Raises:</span></p> <table> <thead> <tr> <th>Type</th> <th>Description</th> </tr> </thead> <tbody> <tr class="doc-section-item"> <td> <code><span title="ValueError">ValueError</span></code> </td> <td> <div class="doc-md-description"> <p>A submitted value does not resolve against this configuration (wrong type, not a choice, out of range). The caller decides whether that means "invalid submission" or, when classifying a historical analysis against a configuration that has since changed, "unknown".</p> </div> </td> </tr> </tbody> </table> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Parameters.validate_unique_keys" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_unique_keys</span><span class="p">(</span><span class="n">custom</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.Parameters.validate_unique_keys" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Keys and names are unique within one configuration.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PasswordPolicy" class="doc doc-heading"> <code>PasswordPolicy</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PasswordPolicy" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The server's password length policy for registration.</p> <p>Exposed so the client validates and hints against the SAME bounds the server enforces, instead of hardcoding them (a tuned policy must never make the sign-up hint lie).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="min_length pydantic-field (yousleep_common.models.api_server.PasswordPolicy.min_length)" href="api_server/#yousleep_common.models.api_server.PasswordPolicy.min_length">min_length</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_length pydantic-field (yousleep_common.models.api_server.PasswordPolicy.max_length)" href="api_server/#yousleep_common.models.api_server.PasswordPolicy.max_length">max_length</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PasswordPolicy.max_length" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_length</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PasswordPolicy.max_length" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Maximum password length accepted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PasswordPolicy.min_length" class="doc doc-heading"> <code class="highlight language-python"><span class="n">min_length</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PasswordPolicy.min_length" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Minimum password length accepted.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PasswordResetEmailRequest" class="doc doc-heading"> <code>PasswordResetEmailRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PasswordResetEmailRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request a password-reset link for an address.</p> <p>The answer is the same whether or not an account with the address exists, so the request cannot be used to probe for accounts.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.authentication.PasswordResetEmailRequest.email)" href="authentication/#yousleep_common.models.authentication.PasswordResetEmailRequest.email">email</a></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PasswordResetEmailRequest.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PasswordResetEmailRequest.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The address of the account whose password is reset.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PendingConsent" class="doc doc-heading"> <code>PendingConsent</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PendingConsent" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A document the user must still accept, and the version to accept.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="document pydantic-field (yousleep_common.models.consent.PendingConsent.document)" href="consent/#yousleep_common.models.consent.PendingConsent.document">document</a></code> (<code><a class="autorefs autorefs-internal" title="ConsentDocument (yousleep_common.types.ConsentDocument)" href="../types/#yousleep_common.types.ConsentDocument">ConsentDocument</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="current_version pydantic-field (yousleep_common.models.consent.PendingConsent.current_version)" href="consent/#yousleep_common.models.consent.PendingConsent.current_version">current_version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PendingConsent.current_version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">current_version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PendingConsent.current_version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The latest version of the document that must be accepted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PendingConsent.document" class="doc doc-heading"> <code class="highlight language-python"><span class="n">document</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PendingConsent.document" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The document requiring acceptance.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PermissionInfo" class="doc doc-heading"> <code>PermissionInfo</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PermissionInfo" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One permission as the server knows it.</p> <p>The vocabulary is served so that a client renders it instead of keeping a copy: an admin's permission editor lists exactly what the server can grant, and an API key dialog offers exactly what a key may carry.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="value pydantic-field (yousleep_common.models.api_server.PermissionInfo.value)" href="api_server/#yousleep_common.models.api_server.PermissionInfo.value">value</a></code> (<code><a class="autorefs autorefs-internal" title="Permission (yousleep_common.types.Permission)" href="../types/#yousleep_common.types.Permission">Permission</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="resource pydantic-field (yousleep_common.models.api_server.PermissionInfo.resource)" href="api_server/#yousleep_common.models.api_server.PermissionInfo.resource">resource</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="action pydantic-field (yousleep_common.models.api_server.PermissionInfo.action)" href="api_server/#yousleep_common.models.api_server.PermissionInfo.action">action</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="key_scopeable pydantic-field (yousleep_common.models.api_server.PermissionInfo.key_scopeable)" href="api_server/#yousleep_common.models.api_server.PermissionInfo.key_scopeable">key_scopeable</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PermissionInfo.action" class="doc doc-heading"> <code class="highlight language-python"><span class="n">action</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PermissionInfo.action" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The part after the colon.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PermissionInfo.key_scopeable" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key_scopeable</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PermissionInfo.key_scopeable" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether an API key may be scoped to this permission. Account and key management never are; the server decides the rest.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PermissionInfo.resource" class="doc doc-heading"> <code class="highlight language-python"><span class="n">resource</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PermissionInfo.resource" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The part before the colon.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PermissionInfo.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PermissionInfo.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The permission, <code>resource:action</code>.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PlatformControlOut" class="doc doc-heading"> <code>PlatformControlOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PlatformControlOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One control: configured default, override if any, and what is in force.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.controls.PlatformControlOut.name">name</span></code> (<code><a class="autorefs autorefs-internal" title="PlatformControlName (yousleep_common.types.admin.PlatformControlName)" href="../types/admin/#yousleep_common.types.admin.PlatformControlName">PlatformControlName</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="configured pydantic-field (yousleep_common.models.controls.PlatformControlOut.configured)" href="controls/#yousleep_common.models.controls.PlatformControlOut.configured">configured</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="override = None pydantic-field (yousleep_common.models.controls.PlatformControlOut.override)" href="controls/#yousleep_common.models.controls.PlatformControlOut.override">override</a></code> (<code><a class="autorefs autorefs-internal" title="PlatformControlOverride pydantic-model (yousleep_common.models.controls.PlatformControlOverride)" href="controls/#yousleep_common.models.controls.PlatformControlOverride">PlatformControlOverride</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="effective pydantic-field (yousleep_common.models.controls.PlatformControlOut.effective)" href="controls/#yousleep_common.models.controls.PlatformControlOut.effective">effective</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOut.configured" class="doc doc-heading"> <code class="highlight language-python"><span class="n">configured</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOut.configured" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The configured value — the default.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOut.effective" class="doc doc-heading"> <code class="highlight language-python"><span class="n">effective</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOut.effective" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The value the platform is applying right now: the override while it lasts, else the configured value.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOut.override" class="doc doc-heading"> <code class="highlight language-python"><span class="n">override</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOut.override" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The live override, or null when none is in force.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PlatformControlOverride" class="doc doc-heading"> <code>PlatformControlOverride</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PlatformControlOverride" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An operator's override of a control, while it lasts.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="enabled pydantic-field (yousleep_common.models.controls.PlatformControlOverride.enabled)" href="controls/#yousleep_common.models.controls.PlatformControlOverride.enabled">enabled</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.controls.PlatformControlOverride.reason)" href="controls/#yousleep_common.models.controls.PlatformControlOverride.reason">reason</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="set_by pydantic-field (yousleep_common.models.controls.PlatformControlOverride.set_by)" href="controls/#yousleep_common.models.controls.PlatformControlOverride.set_by">set_by</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="set_at pydantic-field (yousleep_common.models.controls.PlatformControlOverride.set_at)" href="controls/#yousleep_common.models.controls.PlatformControlOverride.set_at">set_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at pydantic-field (yousleep_common.models.controls.PlatformControlOverride.expires_at)" href="controls/#yousleep_common.models.controls.PlatformControlOverride.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOverride.enabled" class="doc doc-heading"> <code class="highlight language-python"><span class="n">enabled</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOverride.enabled" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The overriding value.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOverride.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOverride.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the configured value takes over again.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOverride.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOverride.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why the operator set it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOverride.set_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">set_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOverride.set_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When it was set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlOverride.set_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">set_by</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlOverride.set_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The administrator who set it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PlatformControlUpdate" class="doc doc-heading"> <code>PlatformControlUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PlatformControlUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Set a control's override.</p> <p>Every override expires; the server bounds how far ahead <code>expires_at</code> may lie. Setting a control that already has an override replaces it, which is also how an override is extended.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="enabled pydantic-field (yousleep_common.models.controls.PlatformControlUpdate.enabled)" href="controls/#yousleep_common.models.controls.PlatformControlUpdate.enabled">enabled</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.controls.PlatformControlUpdate.reason)" href="controls/#yousleep_common.models.controls.PlatformControlUpdate.reason">reason</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at pydantic-field (yousleep_common.models.controls.PlatformControlUpdate.expires_at)" href="controls/#yousleep_common.models.controls.PlatformControlUpdate.expires_at">expires_at</a></code> (<code><span title="pydantic.AwareDatetime">AwareDatetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlUpdate.enabled" class="doc doc-heading"> <code class="highlight language-python"><span class="n">enabled</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlUpdate.enabled" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The value to apply until expiry.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlUpdate.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlUpdate.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the override ends and the configured value returns. Must lie in the future, within the server's maximum override length.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformControlUpdate.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformControlUpdate.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why. Recorded with the change and shown to other administrators.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PlatformControlsOut" class="doc doc-heading"> <code>PlatformControlsOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PlatformControlsOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Every known control.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.controls.PlatformControlsOut.controls">controls</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="PlatformControlOut pydantic-model (yousleep_common.models.controls.PlatformControlOut)" href="controls/#yousleep_common.models.controls.PlatformControlOut">PlatformControlOut</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PlatformStats" class="doc doc-heading"> <code>PlatformStats</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PlatformStats" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Platform-wide statistics.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.admin.PlatformStats.total_users">total_users</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="active_users pydantic-field (yousleep_common.models.admin.PlatformStats.active_users)" href="admin/#yousleep_common.models.admin.PlatformStats.active_users">active_users</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.admin.PlatformStats.disabled_users">disabled_users</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recently_active_users pydantic-field (yousleep_common.models.admin.PlatformStats.recently_active_users)" href="admin/#yousleep_common.models.admin.PlatformStats.recently_active_users">recently_active_users</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recently_active_days pydantic-field (yousleep_common.models.admin.PlatformStats.recently_active_days)" href="admin/#yousleep_common.models.admin.PlatformStats.recently_active_days">recently_active_days</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.admin.PlatformStats.users_by_role">users_by_role</span></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <span title="int">int</span>]</code>) </li> <li> <code><span title="yousleep_common.models.admin.PlatformStats.total_projects">total_projects</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.admin.PlatformStats.total_studies">total_studies</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.admin.PlatformStats.total_recordings">total_recordings</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.admin.PlatformStats.total_analyses">total_analyses</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_bytes_total pydantic-field (yousleep_common.models.admin.PlatformStats.storage_bytes_total)" href="admin/#yousleep_common.models.admin.PlatformStats.storage_bytes_total">storage_bytes_total</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_bytes_stored pydantic-field (yousleep_common.models.admin.PlatformStats.storage_bytes_stored)" href="admin/#yousleep_common.models.admin.PlatformStats.storage_bytes_stored">storage_bytes_stored</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses_by_status pydantic-field (yousleep_common.models.admin.PlatformStats.analyses_by_status)" href="admin/#yousleep_common.models.admin.PlatformStats.analyses_by_status">analyses_by_status</a></code> (<code><span title="dict">dict</span>[<a class="autorefs autorefs-internal" title="AnalysisStatus (yousleep_common.types.AnalysisStatus)" href="../types/#yousleep_common.types.AnalysisStatus">AnalysisStatus</a>, <span title="int">int</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="pending_approvals pydantic-field (yousleep_common.models.admin.PlatformStats.pending_approvals)" href="admin/#yousleep_common.models.admin.PlatformStats.pending_approvals">pending_approvals</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="registrations_24h pydantic-field (yousleep_common.models.admin.PlatformStats.registrations_24h)" href="admin/#yousleep_common.models.admin.PlatformStats.registrations_24h">registrations_24h</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.active_users" class="doc doc-heading"> <code class="highlight language-python"><span class="n">active_users</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.active_users" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Users that are NOT DISABLED. This counts accounts in good standing, not accounts in use — an account that has never been signed into is counted here. For actual usage read <code>recently_active_users</code>, which is what 'active' normally means to a reader.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.analyses_by_status" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses_by_status</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.analyses_by_status" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Live analyses that have not yet settled, by status — the queue as it stands at the time of the request. Statuses with no live analyses are absent rather than zero.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.pending_approvals" class="doc doc-heading"> <code class="highlight language-python"><span class="n">pending_approvals</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.pending_approvals" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Accounts that registered and await an administrator's approval before they can sign in.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.recently_active_days" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recently_active_days</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.recently_active_days" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The window <code>recently_active_users</code> counts over, in days. Reported alongside the count so a reader never has to guess what 'recently' meant, and so the window can change without silently changing what the number means.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.recently_active_users" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recently_active_users</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.recently_active_users" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Users who signed in within <code>recently_active_days</code>. The honest activity figure: derived from each account's last sign-in, so it falls when people stop using the platform, which <code>active_users</code> does not.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.registrations_24h" class="doc doc-heading"> <code class="highlight language-python"><span class="n">registrations_24h</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.registrations_24h" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Accounts created in the last 24 hours, whatever their approval state. A burst here is what the registration control answers.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.storage_bytes_stored" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_bytes_stored</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.storage_bytes_stored" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Bytes actually held across the platform, regardless of whether they count toward an allowance — the 'how much data do we hold' figure, which answers capacity and cost rather than billing. The gap against <code>storage_bytes_total</code> is the storage the platform pays for and does not charge for. Live resources only.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PlatformStats.storage_bytes_total" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_bytes_total</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PlatformStats.storage_bytes_total" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Bytes counting toward storage ALLOWANCES across the platform — what the platform bills for. Excludes resource types configured not to count toward quota and anything external, so it is not the amount of data held; read <code>storage_bytes_stored</code> for that. Live resources only; soft-deleted ones are excluded, matching how per-org quota is measured.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PoolImage" class="doc doc-heading"> <code>PoolImage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PoolImage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An image the runners of a pool may be asked to run.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="reference pydantic-field (yousleep_common.models.runner.PoolImage.reference)" href="runner/#yousleep_common.models.runner.PoolImage.reference">reference</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="kind = LeaseKind.ANALYSIS pydantic-field (yousleep_common.models.runner.PoolImage.kind)" href="runner/#yousleep_common.models.runner.PoolImage.kind">kind</a></code> (<code><a class="autorefs autorefs-internal" title="LeaseKind (yousleep_common.types.runner.LeaseKind)" href="../types/runner/#yousleep_common.types.runner.LeaseKind">LeaseKind</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="smallest_job pydantic-field (yousleep_common.models.runner.PoolImage.smallest_job)" href="runner/#yousleep_common.models.runner.PoolImage.smallest_job">smallest_job</a></code> (<code><a class="autorefs autorefs-internal" title="RunnerCapacity pydantic-model (yousleep_common.models.runner.RunnerCapacity)" href="runner/#yousleep_common.models.runner.RunnerCapacity">RunnerCapacity</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses pydantic-field (yousleep_common.models.runner.PoolImage.analyses)" href="runner/#yousleep_common.models.runner.PoolImage.analyses">analyses</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PoolImage.analyses" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PoolImage.analyses" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analyses that run this image, by configuration id. Empty for a runner an administrator has not yet approved.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PoolImage.kind" class="doc doc-heading"> <code class="highlight language-python"><span class="n">kind</span> <span class="o">=</span> <span class="n">LeaseKind</span><span class="o">.</span><span class="n">ANALYSIS</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PoolImage.kind" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The kind of job that runs the image.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PoolImage.reference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reference</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PoolImage.reference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The image as a runner is asked to run it: its name and tag, and its digest when the analysis declares one.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PoolImage.smallest_job" class="doc doc-heading"> <code class="highlight language-python"><span class="n">smallest_job</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PoolImage.smallest_job" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The least room a job on this image claims: the fewest cores any of its analyses claims, and the least memory any claims for the shortest recording. A runner whose largest job is smaller is never asked to run it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PoolImagesResponse" class="doc doc-heading"> <code>PoolImagesResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PoolImagesResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The images a runner's pool may be asked to run.</p> <p>A runner pulls them ahead of its first job, so a missing registry login or permission shows when the host is set up, not when an analysis waits.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.PoolImagesResponse.images">images</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="PoolImage pydantic-model (yousleep_common.models.runner.PoolImage)" href="runner/#yousleep_common.models.runner.PoolImage">PoolImage</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PreRegistrationResponse" class="doc doc-heading"> <code>PreRegistrationResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PreRegistrationResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="MessageResponse pydantic-model (yousleep_common.models.base_models.MessageResponse)" href="base_models/#yousleep_common.models.base_models.MessageResponse">MessageResponse</a></code></p> <p>Response for recording pre-registration including presigned PUT URL.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.storage.PreRegistrationResponse.message">message</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.storage.PreRegistrationResponse.recording">recording</span></code> (<code><a class="autorefs autorefs-internal" title="RecordingOut pydantic-model (yousleep_common.models.recording.RecordingOut)" href="recording/#yousleep_common.models.recording.RecordingOut">RecordingOut</a></code>) </li> <li> <code><span title="yousleep_common.models.storage.PreRegistrationResponse.presigned_upload">presigned_upload</span></code> (<code><a class="autorefs autorefs-internal" title="PreSignedUploadUrl pydantic-model (yousleep_common.models.storage.PreSignedUploadUrl)" href="storage/#yousleep_common.models.storage.PreSignedUploadUrl">PreSignedUploadUrl</a></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PreSignedDownloadUrl" class="doc doc-heading"> <code>PreSignedDownloadUrl</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PreSignedDownloadUrl" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Pre-signed GET URL for direct S3 download.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.storage.PreSignedDownloadUrl.url">url</span></code> (<code><span title="pydantic.AnyUrl">AnyUrl</span></code>) </li> <li> <code><span title="yousleep_common.models.storage.PreSignedDownloadUrl.filename">filename</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.storage.PreSignedDownloadUrl.expires">expires</span></code> (<code><span title="datetime.timedelta">timedelta</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="etag = None pydantic-field (yousleep_common.models.storage.PreSignedDownloadUrl.etag)" href="storage/#yousleep_common.models.storage.PreSignedDownloadUrl.etag">etag</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PreSignedDownloadUrl.etag" class="doc doc-heading"> <code class="highlight language-python"><span class="n">etag</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PreSignedDownloadUrl.etag" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The object's ETag when it was accepted. A reader that sends it as <code>If-Match</code> is refused with 412 if the object has changed since; null for a recording accepted before ETags were recorded.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PreSignedUploadUrl" class="doc doc-heading"> <code>PreSignedUploadUrl</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PreSignedUploadUrl" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Pre-signed PUT URL for direct S3 upload.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.storage.PreSignedUploadUrl.url">url</span></code> (<code><span title="pydantic.AnyUrl">AnyUrl</span></code>) </li> <li> <code><span title="yousleep_common.models.storage.PreSignedUploadUrl.expires">expires</span></code> (<code><span title="datetime.timedelta">timedelta</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="headers pydantic-field (yousleep_common.models.storage.PreSignedUploadUrl.headers)" href="storage/#yousleep_common.models.storage.PreSignedUploadUrl.headers">headers</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <span title="str">str</span>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PreSignedUploadUrl.headers" class="doc doc-heading"> <code class="highlight language-python"><span class="n">headers</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PreSignedUploadUrl.headers" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Headers the PUT must send, as they are signed into the URL. <code>If-None-Match: *</code> makes the URL create the object once: a second PUT with it is refused with 412 and changes nothing.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Priority" class="doc doc-heading"> <code>Priority</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Priority" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Represents the priority of the analysis.</p> <p>A priority is a non-negative integer where 0 is the lowest priority and higher values indicate higher priority.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="base = 0 pydantic-field (yousleep_common.models.analysis_config.resources.Priority.base)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.Priority.base">base</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Priority.base" class="doc doc-heading"> <code class="highlight language-python"><span class="n">base</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Priority.base" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The base priority of the analysis for any user.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectAnalysisConfig" class="doc doc-heading"> <code>ProjectAnalysisConfig</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectAnalysisConfig" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One analysis configuration a project has completed results from.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.project.ProjectAnalysisConfig.analysis_config_id)" href="project/#yousleep_common.models.project.ProjectAnalysisConfig.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.project.ProjectAnalysisConfig.name)" href="project/#yousleep_common.models.project.ProjectAnalysisConfig.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_count pydantic-field (yousleep_common.models.project.ProjectAnalysisConfig.analysis_count)" href="project/#yousleep_common.models.project.ProjectAnalysisConfig.analysis_count">analysis_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_count pydantic-field (yousleep_common.models.project.ProjectAnalysisConfig.study_count)" href="project/#yousleep_common.models.project.ProjectAnalysisConfig.study_count">study_count</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectAnalysisConfig.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectAnalysisConfig.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The configuration's stable identifier, as reports and analysis requests name it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectAnalysisConfig.analysis_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectAnalysisConfig.analysis_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Completed analyses this configuration produced in the project.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectAnalysisConfig.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectAnalysisConfig.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the configuration.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectAnalysisConfig.study_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectAnalysisConfig.study_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies with at least one completed analysis from it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectCreate" class="doc doc-heading"> <code>ProjectCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="NamedEntityCreate pydantic-model (yousleep_common.models.base_models.NamedEntityCreate)" href="base_models/#yousleep_common.models.base_models.NamedEntityCreate">NamedEntityCreate</a></code></p> <p>Create payload for a project. <code>name</code> is required.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.project.ProjectCreate.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.project.ProjectCreate.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.project.ProjectCreate.name)" href="#yousleep_common.models.NamedEntityCreate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="pseudonymisation pydantic-field (yousleep_common.models.project.ProjectCreate.pseudonymisation)" href="project/#yousleep_common.models.project.ProjectCreate.pseudonymisation">pseudonymisation</a></code> (<code><a class="autorefs autorefs-internal" title="Pseudonymisation pydantic-model (yousleep_common.models.project.Pseudonymisation)" href="project/#yousleep_common.models.project.Pseudonymisation">Pseudonymisation</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="visibility = Visibility.PRIVATE pydantic-field (yousleep_common.models.project.ProjectCreate.visibility)" href="project/#yousleep_common.models.project.ProjectCreate.visibility">visibility</a></code> (<code><a class="autorefs autorefs-internal" title="Visibility (yousleep_common.types.Visibility)" href="../types/#yousleep_common.types.Visibility">Visibility</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectCreate.pseudonymisation" class="doc doc-heading"> <code class="highlight language-python"><span class="n">pseudonymisation</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectCreate.pseudonymisation" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The project's pseudonymisation policy. Fixed when the project is created.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectCreate.visibility" class="doc doc-heading"> <code class="highlight language-python"><span class="n">visibility</span> <span class="o">=</span> <span class="n">Visibility</span><span class="o">.</span><span class="n">PRIVATE</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectCreate.visibility" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Who can access the project: private (its owner only), org (every member of the organization) or shared (its owner plus the members it is explicitly shared with). Defaults to private.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectListResponse" class="doc doc-heading"> <code>ProjectListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of the projects you can open.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.project.ProjectListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.project.ProjectListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.project.ProjectListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.project.ProjectListResponse.projects">projects</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ProjectOut pydantic-model (yousleep_common.models.project.ProjectOut)" href="project/#yousleep_common.models.project.ProjectOut">ProjectOut</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectOut" class="doc doc-heading"> <code>ProjectOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="ProjectCreate pydantic-model (yousleep_common.models.project.ProjectCreate)" href="project/#yousleep_common.models.project.ProjectCreate">ProjectCreate</a></code></p> <p>Project information available to user.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.project.ProjectOut.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.project.ProjectOut.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.project.ProjectOut.name)" href="#yousleep_common.models.NamedEntityCreate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="pseudonymisation pydantic-field (yousleep_common.models.project.ProjectOut.pseudonymisation)" href="#yousleep_common.models.ProjectCreate.pseudonymisation">pseudonymisation</a></code> (<code><a class="autorefs autorefs-internal" title="Pseudonymisation pydantic-model (yousleep_common.models.project.Pseudonymisation)" href="project/#yousleep_common.models.project.Pseudonymisation">Pseudonymisation</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="visibility = Visibility.PRIVATE pydantic-field (yousleep_common.models.project.ProjectOut.visibility)" href="#yousleep_common.models.ProjectCreate.visibility">visibility</a></code> (<code><a class="autorefs autorefs-internal" title="Visibility (yousleep_common.types.Visibility)" href="../types/#yousleep_common.types.Visibility">Visibility</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.project.ProjectOut.id)" href="project/#yousleep_common.models.project.ProjectOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.project.ProjectOut.created_at)" href="project/#yousleep_common.models.project.ProjectOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="owner_id = None pydantic-field (yousleep_common.models.project.ProjectOut.owner_id)" href="project/#yousleep_common.models.project.ProjectOut.owner_id">owner_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_by = None pydantic-field (yousleep_common.models.project.ProjectOut.created_by)" href="project/#yousleep_common.models.project.ProjectOut.created_by">created_by</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recordings_at_site = False pydantic-field (yousleep_common.models.project.ProjectOut.recordings_at_site)" href="project/#yousleep_common.models.project.ProjectOut.recordings_at_site">recordings_at_site</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.study_count)" href="project/#yousleep_common.models.project.ProjectOut.study_count">study_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.recording_count)" href="project/#yousleep_common.models.project.ProjectOut.recording_count">recording_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyzed_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.analyzed_count)" href="project/#yousleep_common.models.project.ProjectOut.analyzed_count">analyzed_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.analyses_count)" href="project/#yousleep_common.models.project.ProjectOut.analyses_count">analyses_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="total_duration_ms = 0 pydantic-field (yousleep_common.models.project.ProjectOut.total_duration_ms)" href="project/#yousleep_common.models.project.ProjectOut.total_duration_ms">total_duration_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lights_complete_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.lights_complete_count)" href="project/#yousleep_common.models.project.ProjectOut.lights_complete_count">lights_complete_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.subject_count)" href="project/#yousleep_common.models.project.ProjectOut.subject_count">subject_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="demographics_count = 0 pydantic-field (yousleep_common.models.project.ProjectOut.demographics_count)" href="project/#yousleep_common.models.project.ProjectOut.demographics_count">demographics_count</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.analyses_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.analyses_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of analyses</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.analyzed_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyzed_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.analyzed_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recordings with >= 1 completed analysis</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Creation timestamp of the project</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.created_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_by</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.created_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user who created the project (null if that user was deleted). Provenance only; it does not change when ownership does.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.demographics_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">demographics_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.demographics_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Subjects with at least one subject-metadata field (age/sex/BMI) set — counted per subject, so a person characterised on thirty nights counts once.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the project</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.lights_complete_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lights_complete_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.lights_complete_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies with BOTH lights markers set (the statistics window is fully defined). The completeness headline pairs this with study_count.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.owner_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">owner_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.owner_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member who owns the project: the only one who can change its visibility, share it or delete it. Ownership passes to the organization's owner when a member leaves.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.recording_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.recording_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of recordings</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.recordings_at_site" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recordings_at_site</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.recordings_at_site" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the project's recordings live in its organisation's bucket rather than on the platform. Fixed when the project is created; its analyses then run only on the organisation's own runners.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.study_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.study_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of studies</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.subject_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.subject_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Distinct subjects among the project's studies. A study with no subject key is its own subject, so a project where nobody set a key reads the same as study_count; where keys are set, this is how many people the studies belong to.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectOut.total_duration_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total_duration_ms</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectOut.total_duration_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total recording duration in ms</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectReportChart" class="doc doc-heading"> <code>ProjectReportChart</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One server-computed chart for a project report stats card.</p> <p>A chart spans every row sharing one value axis — multiple <code>SummaryStats</code> entries — so it attaches to the report envelope, not to an individual stats entry. The identity fields mirror the card grouping (analysis type + config + parameters) so consumers can place each chart on its card without re-deriving geometry.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.reports.ProjectReportChart.key)" href="reports/#yousleep_common.models.reports.ProjectReportChart.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="title pydantic-field (yousleep_common.models.reports.ProjectReportChart.title)" href="reports/#yousleep_common.models.reports.ProjectReportChart.title">title</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="metric pydantic-field (yousleep_common.models.reports.ProjectReportChart.metric)" href="reports/#yousleep_common.models.reports.ProjectReportChart.metric">metric</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_type = None pydantic-field (yousleep_common.models.reports.ProjectReportChart.analysis_type)" href="reports/#yousleep_common.models.reports.ProjectReportChart.analysis_type">analysis_type</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisType (yousleep_common.types.AnalysisType)" href="../types/#yousleep_common.types.AnalysisType">AnalysisType</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.reports.ProjectReportChart.analysis_config_id)" href="reports/#yousleep_common.models.reports.ProjectReportChart.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_parameters pydantic-field (yousleep_common.models.reports.ProjectReportChart.analysis_parameters)" href="reports/#yousleep_common.models.reports.ProjectReportChart.analysis_parameters">analysis_parameters</a></code> (<code><span title="list">list</span>[<span title="tuple">tuple</span>[<span title="str">str</span>, <span title="str">str</span> | <span title="int">int</span> | <span title="float">float</span> | <span title="bool">bool</span>]]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="event_label = None pydantic-field (yousleep_common.models.reports.ProjectReportChart.event_label)" href="reports/#yousleep_common.models.reports.ProjectReportChart.event_label">event_label</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="chart pydantic-field (yousleep_common.models.reports.ProjectReportChart.chart)" href="reports/#yousleep_common.models.reports.ProjectReportChart.chart">chart</a></code> (<code><a class="autorefs autorefs-internal" title="BoxplotModel pydantic-model (yousleep_common.models.charts.BoxplotModel)" href="charts/#yousleep_common.models.charts.BoxplotModel">BoxplotModel</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis configuration the card groups by.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.analysis_parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_parameters</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.analysis_parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis parameters the card groups by.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.analysis_type" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_type</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.analysis_type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis type of the stats card this chart belongs to (None for non-event charts, e.g. future biomarker summaries).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.chart" class="doc doc-heading"> <code class="highlight language-python"><span class="n">chart</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.chart" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The chart geometry.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.event_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">event_label</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.event_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set on by-group comparison charts: the event type this chart compares across study groups. None on single-group charts (rows are the event types).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable chart identity within the report (safe as a render/caching key).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.metric" class="doc doc-heading"> <code class="highlight language-python"><span class="n">metric</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.metric" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Metric the value axis plots (a <code>stats</code> dict key, e.g. 'total-duration-ms').</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportChart.title" class="doc doc-heading"> <code class="highlight language-python"><span class="n">title</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportChart.title" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Human-readable chart heading.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectReportResponse" class="doc doc-heading"> <code>ProjectReportResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Envelope for project-level report data.</p> <p>Wraps aggregated event summary statistics with optional biomarker summary statistics computed across all studies in the project.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="event_stats pydantic-field (yousleep_common.models.reports.ProjectReportResponse.event_stats)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.event_stats">event_stats</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="SummaryStats pydantic-model (yousleep_common.models.events.SummaryStats)" href="events/#yousleep_common.models.events.SummaryStats">SummaryStats</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="statistics_window = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.statistics_window)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.statistics_window">statistics_window</a></code> (<code><a class="autorefs autorefs-internal" title="StatisticsWindow pydantic-model (yousleep_common.models.reports.StatisticsWindow)" href="reports/#yousleep_common.models.reports.StatisticsWindow">StatisticsWindow</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="window_summary = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.window_summary)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.window_summary">window_summary</a></code> (<code><a class="autorefs autorefs-internal" title="ProjectWindowSummary pydantic-model (yousleep_common.models.reports.ProjectWindowSummary)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary">ProjectWindowSummary</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="biomarker_summary = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.biomarker_summary)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.biomarker_summary">biomarker_summary</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="BiomarkerSummaryStats pydantic-model (yousleep_common.models.reports.BiomarkerSummaryStats)" href="reports/#yousleep_common.models.reports.BiomarkerSummaryStats">BiomarkerSummaryStats</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="origins_sets = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.origins_sets)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.origins_sets">origins_sets</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <span title="list">list</span>[<a class="autorefs autorefs-internal" title="StatsOrigin pydantic-model (yousleep_common.models.events.StatsOrigin)" href="events/#yousleep_common.models.events.StatsOrigin">StatsOrigin</a>]] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="warnings pydantic-field (yousleep_common.models.reports.ProjectReportResponse.warnings)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.warnings">warnings</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="charts = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.charts)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.charts">charts</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ProjectReportChart pydantic-model (yousleep_common.models.reports.ProjectReportChart)" href="reports/#yousleep_common.models.reports.ProjectReportChart">ProjectReportChart</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tables = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.tables)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.tables">tables</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="TableModel pydantic-model (yousleep_common.models.tables.TableModel)" href="tables/#yousleep_common.models.tables.TableModel">TableModel</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="stratification = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.stratification)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.stratification">stratification</a></code> (<code><a class="autorefs autorefs-internal" title="ReportStratification pydantic-model (yousleep_common.models.reports.ReportStratification)" href="reports/#yousleep_common.models.reports.ReportStratification">ReportStratification</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="longitudinal = None pydantic-field (yousleep_common.models.reports.ProjectReportResponse.longitudinal)" href="reports/#yousleep_common.models.reports.ProjectReportResponse.longitudinal">longitudinal</a></code> (<code><a class="autorefs autorefs-internal" title="LongitudinalSection pydantic-model (yousleep_common.models.longitudinal.LongitudinalSection)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalSection">LongitudinalSection</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.reports.ProjectReportResponse.credits">credits</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CreditedAnalysis pydantic-model (yousleep_common.models.reports.CreditedAnalysis)" href="reports/#yousleep_common.models.reports.CreditedAnalysis">CreditedAnalysis</a>]</code>) </li> <li> <code><span title="yousleep_common.models.reports.ProjectReportResponse.sections">sections</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ReportSection pydantic-model (yousleep_common.models.reports.ReportSection)" href="reports/#yousleep_common.models.reports.ReportSection">ReportSection</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.biomarker_summary" class="doc doc-heading"> <code class="highlight language-python"><span class="n">biomarker_summary</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.biomarker_summary" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Aggregated biomarker distribution stats grouped by analysis config (None if not requested)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.charts" class="doc doc-heading"> <code class="highlight language-python"><span class="n">charts</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.charts" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-computed chart models for the report's stats cards. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.event_stats" class="doc doc-heading"> <code class="highlight language-python"><span class="n">event_stats</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.event_stats" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Aggregated event summary statistics</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.longitudinal" class="doc doc-heading"> <code class="highlight language-python"><span class="n">longitudinal</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.longitudinal" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set when the report was requested longitudinally: ordered per-metric series with explicit exclusions. The aggregate fields above still describe the whole cohort flat.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.origins_sets" class="doc doc-heading"> <code class="highlight language-python"><span class="n">origins_sets</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.origins_sets" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Shared origins lists, keyed by the <code>origins_ref</code> values carried on <code>event_stats</code> / <code>biomarker_summary</code> entries. On large projects every event family of one analysis configuration shares the same contributing studies, so each distinct list is carried once here instead of repeated per entry. None when all entries carry their origins inline. Use <code>resolve_origins</code> to read an entry's effective origins regardless of representation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.statistics_window" class="doc doc-heading"> <code class="highlight language-python"><span class="n">statistics_window</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.statistics_window" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Deprecated for project reports: the FIRST study's window, kept for older consumers. A project's windows generally differ per study; use window_summary.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.stratification" class="doc doc-heading"> <code class="highlight language-python"><span class="n">stratification</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.stratification" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Set when the report was requested with stratify_by: the factor, the resolved bin edges and per-stratum study counts. None on unstratified reports.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.tables" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tables</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.tables" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-defined tables: per-config distribution and biomarker-summary tables. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.warnings" class="doc doc-heading"> <code class="highlight language-python"><span class="n">warnings</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.warnings" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Warnings about statistics computation</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectReportResponse.window_summary" class="doc doc-heading"> <code class="highlight language-python"><span class="n">window_summary</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectReportResponse.window_summary" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How the studies' statistics windows were resolved — source counts and the length range. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ProjectReportResponse.resolve_origins" class="doc doc-heading"> <code class="highlight language-python"><span class="n">resolve_origins</span><span class="p">(</span><span class="n">entry</span><span class="p">)</span></code> <a href="#yousleep_common.models.ProjectReportResponse.resolve_origins" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the effective origins of a stats entry.</p> <p>Entries carry their origins inline, or reference a shared list on this envelope via <code>origins_ref</code>. Consumers should always read origins through this method rather than <code>entry.origins</code> directly.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectShareCreate" class="doc doc-heading"> <code>ProjectShareCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectShareCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Share a project with one member of its organization.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="user_id pydantic-field (yousleep_common.models.project_share.ProjectShareCreate.user_id)" href="project_share/#yousleep_common.models.project_share.ProjectShareCreate.user_id">user_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareCreate.user_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">user_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareCreate.user_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member to share the project with.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectShareOut" class="doc doc-heading"> <code>ProjectShareOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One member a shared project is open to.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.project_share.ProjectShareOut.id)" href="project_share/#yousleep_common.models.project_share.ProjectShareOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_id pydantic-field (yousleep_common.models.project_share.ProjectShareOut.project_id)" href="project_share/#yousleep_common.models.project_share.ProjectShareOut.project_id">project_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="user_id pydantic-field (yousleep_common.models.project_share.ProjectShareOut.user_id)" href="project_share/#yousleep_common.models.project_share.ProjectShareOut.user_id">user_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.project_share.ProjectShareOut.email)" href="project_share/#yousleep_common.models.project_share.ProjectShareOut.email">email</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.project_share.ProjectShareOut.name)" href="project_share/#yousleep_common.models.project_share.ProjectShareOut.name">name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.project_share.ProjectShareOut.created_at)" href="project_share/#yousleep_common.models.project_share.ProjectShareOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the share was granted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareOut.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>That member's email address.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the share.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareOut.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>That member's display name, if set.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareOut.project_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut.project_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The shared project.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectShareOut.user_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">user_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectShareOut.user_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member the project is shared with.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectUpdate" class="doc doc-heading"> <code>ProjectUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="NamedEntityUpdate pydantic-model (yousleep_common.models.base_models.NamedEntityUpdate)" href="base_models/#yousleep_common.models.base_models.NamedEntityUpdate">NamedEntityUpdate</a></code></p> <p>PATCH payload for a project — all fields are optional.</p> <p>See <code>NamedEntityUpdate</code> for the universal PATCH semantics (omit-to-skip, include-to-set, null-to-clear).</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.project.ProjectUpdate.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.project.ProjectUpdate.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.project.ProjectUpdate.name)" href="#yousleep_common.models.NamedEntityUpdate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="visibility = None pydantic-field (yousleep_common.models.project.ProjectUpdate.visibility)" href="project/#yousleep_common.models.project.ProjectUpdate.visibility">visibility</a></code> (<code><a class="autorefs autorefs-internal" title="Visibility (yousleep_common.types.Visibility)" href="../types/#yousleep_common.types.Visibility">Visibility</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectUpdate.visibility" class="doc doc-heading"> <code class="highlight language-python"><span class="n">visibility</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectUpdate.visibility" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>If set, change who can access the project.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ProjectWindowSummary" class="doc doc-heading"> <code>ProjectWindowSummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>How the statistics windows across a project's studies were resolved.</p> <p>A project-level report aggregates studies whose windows generally differ — in source and in length — so a single window cannot describe it. This summarises: how many studies resolved their window from each source, and the range of window lengths. A study counts as lights-based when its window came from lights events, including one-ended windows where only lights-off or only lights-on was set.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="lights_based pydantic-field (yousleep_common.models.reports.ProjectWindowSummary.lights_based)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary.lights_based">lights_based</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="client_set pydantic-field (yousleep_common.models.reports.ProjectWindowSummary.client_set)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary.client_set">client_set</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="full_recording pydantic-field (yousleep_common.models.reports.ProjectWindowSummary.full_recording)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary.full_recording">full_recording</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="windowless pydantic-field (yousleep_common.models.reports.ProjectWindowSummary.windowless)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary.windowless">windowless</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="min_length_ms = None pydantic-field (yousleep_common.models.reports.ProjectWindowSummary.min_length_ms)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary.min_length_ms">min_length_ms</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_length_ms = None pydantic-field (yousleep_common.models.reports.ProjectWindowSummary.max_length_ms)" href="reports/#yousleep_common.models.reports.ProjectWindowSummary.max_length_ms">max_length_ms</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectWindowSummary.client_set" class="doc doc-heading"> <code class="highlight language-python"><span class="n">client_set</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary.client_set" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies whose window was pinned by a client override.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectWindowSummary.full_recording" class="doc doc-heading"> <code class="highlight language-python"><span class="n">full_recording</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary.full_recording" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies that fell back to the full recording.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectWindowSummary.lights_based" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lights_based</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary.lights_based" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies whose window came from lights events (including one-ended lights windows).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectWindowSummary.max_length_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_length_ms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary.max_length_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Longest resolved window, in ms. None when no study has a window.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectWindowSummary.min_length_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">min_length_ms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary.min_length_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Shortest resolved window, in ms. None when no study has a window.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ProjectWindowSummary.windowless" class="doc doc-heading"> <code class="highlight language-python"><span class="n">windowless</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ProjectWindowSummary.windowless" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies with no resolvable window at all.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Pseudonymisation" class="doc doc-heading"> <code>Pseudonymisation</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Pseudonymisation" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A project's pseudonymisation policy: chosen when it is created, never changed.</p> <p>The EDF patient and recording identification fields are blanked in every project, whatever its policy.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="dates = RecordingDates.REAL pydantic-field (yousleep_common.models.project.Pseudonymisation.dates)" href="project/#yousleep_common.models.project.Pseudonymisation.dates">dates</a></code> (<code><a class="autorefs autorefs-internal" title="RecordingDates (yousleep_common.types.RecordingDates)" href="../types/#yousleep_common.types.RecordingDates">RecordingDates</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="file_names = FileNames.ORIGINAL pydantic-field (yousleep_common.models.project.Pseudonymisation.file_names)" href="project/#yousleep_common.models.project.Pseudonymisation.file_names">file_names</a></code> (<code><a class="autorefs autorefs-internal" title="FileNames (yousleep_common.types.FileNames)" href="../types/#yousleep_common.types.FileNames">FileNames</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Pseudonymisation.dates" class="doc doc-heading"> <code class="highlight language-python"><span class="n">dates</span> <span class="o">=</span> <span class="n">RecordingDates</span><span class="o">.</span><span class="n">REAL</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Pseudonymisation.dates" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether recordings keep their start dates (<code>real</code>) or have them replaced by EDF+'s unknown date before upload (<code>removed</code>); the time of day stays either way.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Pseudonymisation.file_names" class="doc doc-heading"> <code class="highlight language-python"><span class="n">file_names</span> <span class="o">=</span> <span class="n">FileNames</span><span class="o">.</span><span class="n">ORIGINAL</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Pseudonymisation.file_names" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether recordings keep their file names (<code>original</code>) or carry a code instead (<code>coded</code>).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PublicationAnalysis" class="doc doc-heading"> <code>PublicationAnalysis</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PublicationAnalysis" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An analysis whose evidence includes a publication.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.publications.PublicationAnalysis.analysis_config_id)" href="publications/#yousleep_common.models.publications.PublicationAnalysis.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.publications.PublicationAnalysis.name)" href="publications/#yousleep_common.models.publications.PublicationAnalysis.name">name</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PublicationAnalysis.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PublicationAnalysis.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration id.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PublicationAnalysis.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PublicationAnalysis.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis configuration's display name.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PublicationFamily" class="doc doc-heading"> <code>PublicationFamily</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PublicationFamily" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A family of analyses the listing can be narrowed to.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.publications.PublicationFamily.name)" href="publications/#yousleep_common.models.publications.PublicationFamily.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="shown_by_default pydantic-field (yousleep_common.models.publications.PublicationFamily.shown_by_default)" href="publications/#yousleep_common.models.publications.PublicationFamily.shown_by_default">shown_by_default</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PublicationFamily.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PublicationFamily.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The family's name, e.g. 'U-Sleep'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PublicationFamily.shown_by_default" class="doc doc-heading"> <code class="highlight language-python"><span class="n">shown_by_default</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PublicationFamily.shown_by_default" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether a reader who has not chosen sees this family's publications: youSleep's own analyses are shown, other developers' are one choice away.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.PublicationListing" class="doc doc-heading"> <code>PublicationListing</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.PublicationListing" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Every publication the platform lists.</p> <p>A citation list, not a census: there may be further work that is not listed. Present a count as a floor.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="families pydantic-field (yousleep_common.models.publications.PublicationListing.families)" href="publications/#yousleep_common.models.publications.PublicationListing.families">families</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="PublicationFamily pydantic-model (yousleep_common.models.publications.PublicationFamily)" href="publications/#yousleep_common.models.publications.PublicationFamily">PublicationFamily</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="publications pydantic-field (yousleep_common.models.publications.PublicationListing.publications)" href="publications/#yousleep_common.models.publications.PublicationListing.publications">publications</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ListedPublication pydantic-model (yousleep_common.models.publications.ListedPublication)" href="publications/#yousleep_common.models.publications.ListedPublication">ListedPublication</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PublicationListing.families" class="doc doc-heading"> <code class="highlight language-python"><span class="n">families</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PublicationListing.families" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The families the listing can be narrowed to, those shown by default first.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.PublicationListing.publications" class="doc doc-heading"> <code class="highlight language-python"><span class="n">publications</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.PublicationListing.publications" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The publications: youSleep's own, then other developers', then independent work, each newest first.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Purpose" class="doc doc-heading"> <code>Purpose</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.Purpose" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Describes the analysis' type/outputs and purpose.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_types pydantic-field (yousleep_common.models.analysis_config.metadata.Purpose.analysis_types)" href="analysis_config/metadata/#yousleep_common.models.analysis_config.metadata.Purpose.analysis_types">analysis_types</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AnalysisType (yousleep_common.types.AnalysisType)" href="../types/#yousleep_common.types.AnalysisType">AnalysisType</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="description pydantic-field (yousleep_common.models.analysis_config.metadata.Purpose.description)" href="analysis_config/metadata/#yousleep_common.models.analysis_config.metadata.Purpose.description">description</a></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tags pydantic-field (yousleep_common.models.analysis_config.metadata.Purpose.tags)" href="analysis_config/metadata/#yousleep_common.models.analysis_config.metadata.Purpose.tags">tags</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Purpose.analysis_types" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_types</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Purpose.analysis_types" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type(s) of analysis/anlyses (e.g., 'STAGING') that the analysis supports.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Purpose.description" class="doc doc-heading"> <code class="highlight language-python"><span class="n">description</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Purpose.description" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A brief description of the analysis.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.Purpose.tags" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tags</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.Purpose.tags" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional free-form tags for categorising/sorting the analysis in clients (e.g. 'example' to mark demo configs, which clients sort last and badge).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.QCMetrics" class="doc doc-heading"> <code>QCMetrics</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.QCMetrics" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Quality metrics for a sleep analysis.</p> <p>Confidence-dependent fields are None when events lack probability (non-probabilistic analysis configs).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total_epochs pydantic-field (yousleep_common.models.biomarkers.QCMetrics.total_epochs)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.total_epochs">total_epochs</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="valid_epochs pydantic-field (yousleep_common.models.biomarkers.QCMetrics.valid_epochs)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.valid_epochs">valid_epochs</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="artifact_epochs pydantic-field (yousleep_common.models.biomarkers.QCMetrics.artifact_epochs)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.artifact_epochs">artifact_epochs</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="artifact_pct pydantic-field (yousleep_common.models.biomarkers.QCMetrics.artifact_pct)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.artifact_pct">artifact_pct</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_completeness_pct pydantic-field (yousleep_common.models.biomarkers.QCMetrics.recording_completeness_pct)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.recording_completeness_pct">recording_completeness_pct</a></code> (<code><span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="confidence_mean = None pydantic-field (yousleep_common.models.biomarkers.QCMetrics.confidence_mean)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.confidence_mean">confidence_mean</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="confidence_min = None pydantic-field (yousleep_common.models.biomarkers.QCMetrics.confidence_min)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.confidence_min">confidence_min</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="confidence_p5 = None pydantic-field (yousleep_common.models.biomarkers.QCMetrics.confidence_p5)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.confidence_p5">confidence_p5</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="entropy = None pydantic-field (yousleep_common.models.biomarkers.QCMetrics.entropy)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.entropy">entropy</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="transition_confidence = None pydantic-field (yousleep_common.models.biomarkers.QCMetrics.transition_confidence)" href="biomarkers/#yousleep_common.models.biomarkers.QCMetrics.transition_confidence">transition_confidence</a></code> (<code><span title="float">float</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.artifact_epochs" class="doc doc-heading"> <code class="highlight language-python"><span class="n">artifact_epochs</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.artifact_epochs" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of artifact-flagged epochs</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.artifact_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">artifact_pct</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.artifact_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Percentage of epochs flagged as artifact</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.confidence_mean" class="doc doc-heading"> <code class="highlight language-python"><span class="n">confidence_mean</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.confidence_mean" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Mean confidence across all epochs</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.confidence_min" class="doc doc-heading"> <code class="highlight language-python"><span class="n">confidence_min</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.confidence_min" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Minimum confidence across all epochs</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.confidence_p5" class="doc doc-heading"> <code class="highlight language-python"><span class="n">confidence_p5</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.confidence_p5" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>5th percentile confidence</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.entropy" class="doc doc-heading"> <code class="highlight language-python"><span class="n">entropy</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.entropy" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Staging entropy — true Shannon entropy from full 5-class softmax when available, argmax-based proxy otherwise</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.recording_completeness_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_completeness_pct</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.recording_completeness_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Percentage of recording length covered by events</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.total_epochs" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total_epochs</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.total_epochs" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of epochs</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.transition_confidence" class="doc doc-heading"> <code class="highlight language-python"><span class="n">transition_confidence</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.transition_confidence" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Mean confidence at epochs where the sleep stage changes</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QCMetrics.valid_epochs" class="doc doc-heading"> <code class="highlight language-python"><span class="n">valid_epochs</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QCMetrics.valid_epochs" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of non-artifact epochs</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.QualityRequirement" class="doc doc-heading"> <code>QualityRequirement</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.QualityRequirement" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Data quality requirements for a channel.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="score pydantic-field (yousleep_common.models.analysis_config.channels.QualityRequirement.score)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.QualityRequirement.score">score</a></code> (<code><a class="autorefs autorefs-internal" title="Range (yousleep_common.models.analysis_config.primitives.Range)" href="analysis_config/primitives/#yousleep_common.models.analysis_config.primitives.Range">Range</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="method pydantic-field (yousleep_common.models.analysis_config.channels.QualityRequirement.method)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.QualityRequirement.method">method</a></code> (<code><a class="autorefs autorefs-internal" title="SignalQualityScoreMethod (yousleep_common.types.SignalQualityScoreMethod)" href="../types/#yousleep_common.types.SignalQualityScoreMethod">SignalQualityScoreMethod</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="mode pydantic-field (yousleep_common.models.analysis_config.channels.QualityRequirement.mode)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.QualityRequirement.mode">mode</a></code> (<code><a class="autorefs autorefs-internal" title="SignalQualityScoreMode (yousleep_common.types.SignalQualityScoreMode)" href="../types/#yousleep_common.types.SignalQualityScoreMode">SignalQualityScoreMode</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QualityRequirement.method" class="doc doc-heading"> <code class="highlight language-python"><span class="n">method</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QualityRequirement.method" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The method used to calculate the quality metric. These methods are implemented by the platform and not by the individual analyses.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QualityRequirement.mode" class="doc doc-heading"> <code class="highlight language-python"><span class="n">mode</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QualityRequirement.mode" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The mode in which the quality metric is calculated and used. Modes can be 'global' or 'per_epoch'. If global, the channel cannot be passed to the analysis if the whole-recording quality is below the min_quality. If per_epoch, the channel can be passed to the analysis. If 'per_epoch', the analysis will receive the channel but the platform will indicate that any events within epochs with quality below min_quality should be considered uncertain.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.QualityRequirement.score" class="doc doc-heading"> <code class="highlight language-python"><span class="n">score</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.QualityRequirement.score" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The range of acceptable values for the quality metric.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.Range" class="doc doc-heading"> <code>Range</code> <a href="#yousleep_common.models.Range" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.RootModel">RootModel</span></code></p> <p>Represents a range between a minimum and maximum value.</p> <p>Both values are inclusive and the minimum value is less than or equal to the maximum value. A maximum value of None indicates that there is no upper limit (+inf). A minimum value of None indicates that there is no lower limit (-inf). String literals "+inf" and "-inf" are also allowed.</p> <div class="doc doc-children"> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Range.__contains__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__contains__</span><span class="p">(</span><span class="n">item</span><span class="p">)</span></code> <a href="#yousleep_common.models.Range.__contains__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Check if the item is within the range.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Range.__getitem__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__getitem__</span><span class="p">(</span><span class="n">item</span><span class="p">)</span></code> <a href="#yousleep_common.models.Range.__getitem__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the value at the given index.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Range.__iter__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__iter__</span><span class="p">()</span></code> <a href="#yousleep_common.models.Range.__iter__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return an iterator over the range values.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Range.serialize_range" class="doc doc-heading"> <code class="highlight language-python"><span class="n">serialize_range</span><span class="p">()</span></code> <a href="#yousleep_common.models.Range.serialize_range" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Convert float(+/-inf) to string (+/-inf) for JSON serialization.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.Range.validate_range" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_range</span><span class="p">(</span><span class="n">values</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-classmethod"><code>classmethod</code></small> </span> <a href="#yousleep_common.models.Range.validate_range" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate the range values.</p> <p>Validate the range values and handles conversion of string inf literals to floats and specification as root or 'range' key in the dictionary.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RecordingAnalysisSummary" class="doc doc-heading"> <code>RecordingAnalysisSummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RecordingAnalysisSummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Compact per-recording analysis summary (id + status + config name).</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.recording.RecordingAnalysisSummary.id">id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingAnalysisSummary.status">status</span></code> (<code><a class="autorefs autorefs-internal" title="AnalysisStatus (yousleep_common.types.AnalysisStatus)" href="../types/#yousleep_common.types.AnalysisStatus">AnalysisStatus</a></code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingAnalysisSummary.analysis_config_name">analysis_config_name</span></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RecordingHeader" class="doc doc-heading"> <code>RecordingHeader</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RecordingHeader" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Model with information that header reading functions should return.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.recording.RecordingHeader.channels">channels</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelOut pydantic-model (yousleep_common.models.channel.ChannelOut)" href="channel/#yousleep_common.models.channel.ChannelOut">ChannelOut</a>]</code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingHeader.length_ms">length_ms</span></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingHeader.recording_start">recording_start</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RecordingInput" class="doc doc-heading"> <code>RecordingInput</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RecordingInput" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Defines a recording type input for the analysis.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="format = FileFormat.EDF pydantic-field (yousleep_common.models.analysis_config.channels.RecordingInput.format)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.format">format</a></code> (<code><a class="autorefs autorefs-internal" title="FileFormat (yousleep_common.types.FileFormat)" href="../types/#yousleep_common.types.FileFormat">FileFormat</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="allow_multiple = False pydantic-field (yousleep_common.models.analysis_config.channels.RecordingInput.allow_multiple)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.allow_multiple">allow_multiple</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="description = None pydantic-field (yousleep_common.models.analysis_config.channels.RecordingInput.description)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.description">description</a></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="minimum_duration_seconds = 1 pydantic-field (yousleep_common.models.analysis_config.channels.RecordingInput.minimum_duration_seconds)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.minimum_duration_seconds">minimum_duration_seconds</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channels = [] pydantic-field (yousleep_common.models.analysis_config.channels.RecordingInput.channels)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.channels">channels</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ExactChannelRequirement pydantic-model (yousleep_common.models.analysis_config.channels.ExactChannelRequirement)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ExactChannelRequirement">ExactChannelRequirement</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channel_types = [] pydantic-field (yousleep_common.models.analysis_config.channels.RecordingInput.channel_types)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.channel_types">channel_types</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelTypeRequirement pydantic-model (yousleep_common.models.analysis_config.channels.ChannelTypeRequirement)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.ChannelTypeRequirement">ChannelTypeRequirement</a>] | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_channels(data) pydantic-validator (yousleep_common.models.analysis_config.channels.RecordingInput.validate_channels)" href="analysis_config/channels/#yousleep_common.models.analysis_config.channels.RecordingInput.validate_channels">validate_channels</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingInput.allow_multiple" class="doc doc-heading"> <code class="highlight language-python"><span class="n">allow_multiple</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingInput.allow_multiple" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the analysis supports multiple input files passed as a list of paths to 'argument' (see default parameters). Default is False, in which case a single path is passed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingInput.channel_types" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channel_types</span> <span class="o">=</span> <span class="p">[]</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingInput.channel_types" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The list of channel types that the analysis expects and their requirements. Can be None if the analysis does not support general channels by types but requires exact channel deriviations only (see channels).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingInput.channels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channels</span> <span class="o">=</span> <span class="p">[]</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingInput.channels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The list of exact channels deriviations that the analysis expects and their requirements. Can be None if the analysis does not require any specific channels but any channels of certain types (see channel_types).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingInput.description" class="doc doc-heading"> <code class="highlight language-python"><span class="n">description</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingInput.description" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A brief description of the input.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingInput.format" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">format</span> <span class="o">=</span> <span class="n">FileFormat</span><span class="o">.</span><span class="n">EDF</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingInput.format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The format of the input file, e.g., 'edf'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingInput.minimum_duration_seconds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">minimum_duration_seconds</span> <span class="o">=</span> <span class="mi">1</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingInput.minimum_duration_seconds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The minimum duration of the input in seconds. Must be greater than 0.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.RecordingInput.validate_channels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_channels</span><span class="p">(</span><span class="n">data</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.RecordingInput.validate_channels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that at least one of 'channels' and 'channel_types' is set.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RecordingOut" class="doc doc-heading"> <code>RecordingOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RecordingOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="RecordingUpdate pydantic-model (yousleep_common.models.recording.RecordingUpdate)" href="recording/#yousleep_common.models.recording.RecordingUpdate">RecordingUpdate</a></code>, <code><a class="autorefs autorefs-internal" title="RecordingHeader pydantic-model (yousleep_common.models.recording.RecordingHeader)" href="recording/#yousleep_common.models.recording.RecordingHeader">RecordingHeader</a></code></p> <p>Recording information available to user.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.recording.RecordingOut.channels">channels</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelOut pydantic-model (yousleep_common.models.channel.ChannelOut)" href="channel/#yousleep_common.models.channel.ChannelOut">ChannelOut</a>]</code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingOut.length_ms">length_ms</span></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingOut.recording_start">recording_start</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="owner_id = None pydantic-field (yousleep_common.models.recording.RecordingOut.owner_id)" href="recording/#yousleep_common.models.recording.RecordingOut.owner_id">owner_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.recording.RecordingOut.id)" href="recording/#yousleep_common.models.recording.RecordingOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.recording.RecordingOut.created_at)" href="recording/#yousleep_common.models.recording.RecordingOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><span title="yousleep_common.models.recording.RecordingOut.original_filename">original_filename</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="file_size_bytes pydantic-field (yousleep_common.models.recording.RecordingOut.file_size_bytes)" href="recording/#yousleep_common.models.recording.RecordingOut.file_size_bytes">file_size_bytes</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="format pydantic-field (yousleep_common.models.recording.RecordingOut.format)" href="recording/#yousleep_common.models.recording.RecordingOut.format">format</a></code> (<code><a class="autorefs autorefs-internal" title="FileFormat (yousleep_common.types.FileFormat)" href="../types/#yousleep_common.types.FileFormat">FileFormat</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="state pydantic-field (yousleep_common.models.recording.RecordingOut.state)" href="recording/#yousleep_common.models.recording.RecordingOut.state">state</a></code> (<code><a class="autorefs autorefs-internal" title="FileUploadState (yousleep_common.types.FileUploadState)" href="../types/#yousleep_common.types.FileUploadState">FileUploadState</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="checksum = None pydantic-field (yousleep_common.models.recording.RecordingOut.checksum)" href="recording/#yousleep_common.models.recording.RecordingOut.checksum">checksum</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_id = None pydantic-field (yousleep_common.models.recording.RecordingOut.study_id)" href="recording/#yousleep_common.models.recording.RecordingOut.study_id">study_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_name = None pydantic-field (yousleep_common.models.recording.RecordingOut.study_name)" href="recording/#yousleep_common.models.recording.RecordingOut.study_name">study_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses pydantic-field (yousleep_common.models.recording.RecordingOut.analyses)" href="recording/#yousleep_common.models.recording.RecordingOut.analyses">analyses</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="RecordingAnalysisSummary pydantic-model (yousleep_common.models.recording.RecordingAnalysisSummary)" href="recording/#yousleep_common.models.recording.RecordingAnalysisSummary">RecordingAnalysisSummary</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="missing_since = None pydantic-field (yousleep_common.models.recording.RecordingOut.missing_since)" href="recording/#yousleep_common.models.recording.RecordingOut.missing_since">missing_since</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.analyses" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.analyses" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-recording analysis summaries (id, status, config name).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.checksum" class="doc doc-heading"> <code class="highlight language-python"><span class="n">checksum</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.checksum" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The SHA1/MD5 hash of the file. May be None. May contain a '-{number of parts}' of up to 4 digits of parts suffix. E.g., {checksum}-4 or {checksum}-0001</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The date and time when the recording was created.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.file_size_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">file_size_bytes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.file_size_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Size of the file in bytes</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.format" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">format</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The format of the file, e.g., 'edf'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The unique identifier of the recording.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.missing_since" class="doc doc-heading"> <code class="highlight language-python"><span class="n">missing_since</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.missing_since" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When a look for new files found the bucket file it was registered from gone from its key, or changed there; null while it is there. New analyses of a missing recording are refused.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.owner_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">owner_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.owner_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member who added it. Only they, or the project's owner, may change or remove it; it passes to the project's owner when they leave the organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.state" class="doc doc-heading"> <code class="highlight language-python"><span class="n">state</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.state" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The state of the file, e.g., 'registered'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.study_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.study_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>ID of the parent study. Populated in flat project-level listings.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RecordingOut.study_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RecordingOut.study_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Name of the parent study. Populated in flat project-level listings.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RecordingSelector" class="doc doc-heading"> <code>RecordingSelector</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RecordingSelector" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.selectors._SelectorBase">_SelectorBase</span></code></p> <p>Address a set of recordings: exactly one of <code>ids</code> | <code>all</code>.</p> <p>Recordings carry no filterable attributes of their own yet, so this selector has no filter mode; it exists so every batch write speaks the same addressing language.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.RecordingSelector.ids">ids</span></code> (<code><span title="list">list</span>[<span title="uuid.UUID">UUID</span>] | None</code>) </li> <li> <code><span title="yousleep_common.models.selectors.RecordingSelector.all">all</span></code> (<code><span title="bool">bool</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.RecordingSelector._exactly_one_mode">_exactly_one_mode</span></code> </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RecordingUpdate" class="doc doc-heading"> <code>RecordingUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RecordingUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Updatable file fields.</p> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RemoteFileMapping" class="doc doc-heading"> <code>RemoteFileMapping</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RemoteFileMapping" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Represents a remote file mapping for the analysis submission.</p> <p>A remote file mapping is used to map how a remotely located input or output file should be mapped to/from the local file system of the analysis container by a controller.</p> <p>For instance, an input file may be stored in s3 and should be downloaded to the local file system of the analysis container before the analysis is run. The output file of an analysis may similarly be requested to be stored in s3 after the analysis is run.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="remote_url pydantic-field (yousleep_common.models.analysis_submission.RemoteFileMapping.remote_url)" href="analysis_submission/#yousleep_common.models.analysis_submission.RemoteFileMapping.remote_url">remote_url</a></code> (<code><span title="pydantic.AnyUrl">AnyUrl</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="container_path pydantic-field (yousleep_common.models.analysis_submission.RemoteFileMapping.container_path)" href="analysis_submission/#yousleep_common.models.analysis_submission.RemoteFileMapping.container_path">container_path</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.analysis_submission.RemoteFileMapping.type)" href="analysis_submission/#yousleep_common.models.analysis_submission.RemoteFileMapping.type">type</a></code> (<code><span title="typing.Literal">Literal</span>['input', 'output']</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="size_bytes = None pydantic-field (yousleep_common.models.analysis_submission.RemoteFileMapping.size_bytes)" href="analysis_submission/#yousleep_common.models.analysis_submission.RemoteFileMapping.size_bytes">size_bytes</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_remote_url(url) pydantic-validator (yousleep_common.models.analysis_submission.RemoteFileMapping.validate_remote_url)" href="analysis_submission/#yousleep_common.models.analysis_submission.RemoteFileMapping.validate_remote_url">validate_remote_url</a></code> → <code><a class="autorefs autorefs-internal" title="remote_url pydantic-field (yousleep_common.models.analysis_submission.RemoteFileMapping.remote_url)" href="analysis_submission/#yousleep_common.models.analysis_submission.RemoteFileMapping.remote_url">remote_url</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RemoteFileMapping.container_path" class="doc doc-heading"> <code class="highlight language-python"><span class="n">container_path</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RemoteFileMapping.container_path" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The path in the container where the file should be mounted. This is the path where the file will be available in the analysis container. Can be absolute or relative.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RemoteFileMapping.remote_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">remote_url</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RemoteFileMapping.remote_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The URL to the original file location. Must be an https, s3 bucket or file URL.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RemoteFileMapping.size_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">size_bytes</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RemoteFileMapping.size_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Size of the remote file in bytes, when known at submission build time. Lets consumers (disk-space planning, runners) skip a per-file storage lookup. None when unknown — e.g. output files that do not exist yet.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RemoteFileMapping.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RemoteFileMapping.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type of the file mapping. Can be either 'input' or 'output'. Input files must be downloaded before the analysis is run and mounted in the container. Output files must be uploaded after the analysis is run.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.RemoteFileMapping.validate_remote_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_remote_url</span><span class="p">(</span><span class="n">url</span><span class="p">)</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.RemoteFileMapping.validate_remote_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate the remote URL to ensure it is a s3 URL (currently only supported scheme).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportAnalysisInfo" class="doc doc-heading"> <code>ReportAnalysisInfo</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Analysis metadata for reports.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_id pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.analysis_id)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.analysis_id">analysis_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_types pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.analysis_types)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.analysis_types">analysis_types</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AnalysisType (yousleep_common.types.AnalysisType)" href="../types/#yousleep_common.types.AnalysisType">AnalysisType</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.analysis_config_id)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_name pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.analysis_config_name)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.analysis_config_name">analysis_config_name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="status pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.status)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.status">status</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisStatus (yousleep_common.types.AnalysisStatus)" href="../types/#yousleep_common.types.AnalysisStatus">AnalysisStatus</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="parameters pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.parameters)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.parameters">parameters</a></code> (<code><span title="list">list</span>[<span title="tuple">tuple</span>[<span title="str">str</span>, <span title="str">str</span> | <span title="int">int</span> | <span title="float">float</span> | <span title="bool">bool</span>]]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_version = None pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.analysis_config_version)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.analysis_config_version">analysis_config_version</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="completed_at = None pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.completed_at)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.completed_at">completed_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channels = None pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.channels)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.channels">channels</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="research_parameters = None pydantic-field (yousleep_common.models.reports.ReportAnalysisInfo.research_parameters)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo.research_parameters">research_parameters</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis config identifier</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.analysis_config_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.analysis_config_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis config name</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.analysis_config_version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_version</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.analysis_config_version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Version of the analysis configuration that produced the results — provenance for the report audit appendix. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.analysis_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.analysis_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Short analysis identifier</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.analysis_types" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_types</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.analysis_types" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Types of analysis</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.channels" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channels</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.channels" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Channel names the analysis ran on — provenance for reports. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.completed_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">completed_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.completed_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the analysis completed — provenance for the report audit appendix. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">parameters</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis parameters</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.research_parameters" class="doc doc-heading"> <code class="highlight language-python"><span class="n">research_parameters</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.research_parameters" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Parameters (by API name) whose value lay outside the analysis's validated regime, marking this analysis's outputs as exploratory. Empty when every parameter was within the regime. None when not derived (producers predating the field, or a configuration change made the submitted values unresolvable).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnalysisInfo.status" class="doc doc-heading"> <code class="highlight language-python"><span class="n">status</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnalysisInfo.status" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis status</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportAnnotatedEvents" class="doc doc-heading"> <code>ReportAnnotatedEvents</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportAnnotatedEvents" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Events with associated analysis metadata for reports.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.reports.ReportAnnotatedEvents.events">events</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="Event pydantic-model (yousleep_common.models.events.Event)" href="events/#yousleep_common.models.events.Event">Event</a>]</code>) </li> <li> <code><span title="yousleep_common.models.reports.ReportAnnotatedEvents.analysis">analysis</span></code> (<code><a class="autorefs autorefs-internal" title="ReportAnalysisInfo pydantic-model (yousleep_common.models.reports.ReportAnalysisInfo)" href="reports/#yousleep_common.models.reports.ReportAnalysisInfo">ReportAnalysisInfo</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_length_ms = None pydantic-field (yousleep_common.models.reports.ReportAnnotatedEvents.recording_length_ms)" href="reports/#yousleep_common.models.reports.ReportAnnotatedEvents.recording_length_ms">recording_length_ms</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportAnnotatedEvents.recording_length_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_length_ms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportAnnotatedEvents.recording_length_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Length of the source recording in milliseconds, used for coverage % computation</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportExportCreate" class="doc doc-heading"> <code>ReportExportCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportExportCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request body for creating a report export.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="format pydantic-field (yousleep_common.models.report_export.ReportExportCreate.format)" href="report_export/#yousleep_common.models.report_export.ReportExportCreate.format">format</a></code> (<code><span title="yousleep_common.models.report_export.ReportExportFormat">ReportExportFormat</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="events_params = None pydantic-field (yousleep_common.models.report_export.ReportExportCreate.events_params)" href="report_export/#yousleep_common.models.report_export.ReportExportCreate.events_params">events_params</a></code> (<code><a class="autorefs autorefs-internal" title="EventsExportParams pydantic-model (yousleep_common.models.report_export.EventsExportParams)" href="report_export/#yousleep_common.models.report_export.EventsExportParams">EventsExportParams</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="layout = None pydantic-field (yousleep_common.models.report_export.ReportExportCreate.layout)" href="report_export/#yousleep_common.models.report_export.ReportExportCreate.layout">layout</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="SectionLayoutEntry pydantic-model (yousleep_common.models.report_export.SectionLayoutEntry)" href="report_export/#yousleep_common.models.report_export.SectionLayoutEntry">SectionLayoutEntry</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_params = None pydantic-field (yousleep_common.models.report_export.ReportExportCreate.project_params)" href="report_export/#yousleep_common.models.report_export.ReportExportCreate.project_params">project_params</a></code> (<code><a class="autorefs autorefs-internal" title="ReportExportProjectParams pydantic-model (yousleep_common.models.report_export.ReportExportProjectParams)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams">ReportExportProjectParams</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email_copy = False pydantic-field (yousleep_common.models.report_export.ReportExportCreate.email_copy)" href="report_export/#yousleep_common.models.report_export.ReportExportCreate.email_copy">email_copy</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportCreate.email_copy" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email_copy</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportCreate.email_copy" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Also email the artifact link to the requesting user's verified address once the export completes. NOT YET HONORED: the server rejects true until the email delivery path ships.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportCreate.events_params" class="doc doc-heading"> <code class="highlight language-python"><span class="n">events_params</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportCreate.events_params" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>events-zip exports only: which studies to bundle. Rejected for document formats.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportCreate.format" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">format</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportCreate.format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Artifact format to render.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportCreate.layout" class="doc doc-heading"> <code class="highlight language-python"><span class="n">layout</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportCreate.layout" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Section selection/order to apply; omitted = every section in natural order. Snapshotted on the export.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportCreate.project_params" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_params</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportCreate.project_params" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Project exports only: which report mode to render. None = by-group over every tag.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportExportListResponse" class="doc doc-heading"> <code>ReportExportListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportExportListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of the user's report exports, newest first.</p> <p>Paginated like the other listings: <code>total</code> is the whole collection, not the page, so a client can show how many exports exist and page through them rather than treating one capped read as the whole history.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.report_export.ReportExportListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.report_export.ReportExportListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.report_export.ReportExportListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="exports pydantic-field (yousleep_common.models.report_export.ReportExportListResponse.exports)" href="report_export/#yousleep_common.models.report_export.ReportExportListResponse.exports">exports</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ReportExportOut pydantic-model (yousleep_common.models.report_export.ReportExportOut)" href="report_export/#yousleep_common.models.report_export.ReportExportOut">ReportExportOut</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportListResponse.exports" class="doc doc-heading"> <code class="highlight language-python"><span class="n">exports</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportListResponse.exports" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The exports on this page.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportExportOut" class="doc doc-heading"> <code>ReportExportOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportExportOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One report export and its lifecycle state.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="owner_id = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.owner_id)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.owner_id">owner_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.report_export.ReportExportOut.id)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="kind pydantic-field (yousleep_common.models.report_export.ReportExportOut.kind)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.kind">kind</a></code> (<code><span title="yousleep_common.models.report_export.ReportExportKind">ReportExportKind</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_id pydantic-field (yousleep_common.models.report_export.ReportExportOut.project_id)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.project_id">project_id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_id = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.study_id)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.study_id">study_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_name = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.project_name)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.project_name">project_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_name = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.study_name)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.study_name">study_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="format pydantic-field (yousleep_common.models.report_export.ReportExportOut.format)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.format">format</a></code> (<code><span title="yousleep_common.models.report_export.ReportExportFormat">ReportExportFormat</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="status pydantic-field (yousleep_common.models.report_export.ReportExportOut.status)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.status">status</a></code> (<code><span title="yousleep_common.models.report_export.ReportExportStatus">ReportExportStatus</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="error = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.error)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.error">error</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="size_bytes = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.size_bytes)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.size_bytes">size_bytes</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.report_export.ReportExportOut.created_at)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="completed_at = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.completed_at)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.completed_at">completed_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.expires_at)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="download_url = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.download_url)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.download_url">download_url</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="appendix_download_url = None pydantic-field (yousleep_common.models.report_export.ReportExportOut.appendix_download_url)" href="report_export/#yousleep_common.models.report_export.ReportExportOut.appendix_download_url">appendix_download_url</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.appendix_download_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">appendix_download_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.appendix_download_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Short-lived download URL for the export's audit-appendix CSV snapshot, for formats that keep the appendix out of the main artifact (PDF). Present only while completed and not expired; None for formats that embed the appendix and for rows predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.completed_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">completed_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.completed_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When rendering finished (success or failure).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the export was requested.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.download_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">download_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.download_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Short-lived download URL; present only while completed and not expired.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.error" class="doc doc-heading"> <code class="highlight language-python"><span class="n">error</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.error" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Failure reason when status is failed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the artifact is deleted; absent until completed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.format" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">format</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Artifact format.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Export identifier.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.kind" class="doc doc-heading"> <code class="highlight language-python"><span class="n">kind</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.kind" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Study or project report.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.owner_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">owner_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.owner_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member who added it. Only they, or the project's owner, may change or remove it; it passes to the project's owner when they leave the organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.project_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.project_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The project the report belongs to.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.project_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.project_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the project at export time. None for rows predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.size_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">size_bytes</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.size_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Artifact size once completed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.status" class="doc doc-heading"> <code class="highlight language-python"><span class="n">status</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.status" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Lifecycle state.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.study_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.study_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The study, for study-report exports.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportOut.study_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportOut.study_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the study at export time, for study-report exports. None otherwise or predating.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportExportProjectParams" class="doc doc-heading"> <code>ReportExportProjectParams</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Project-report mode selection for an export.</p> <p>The field NAMES mirror the report GET's query parameters; <code>by_group</code>'s DEFAULT does not. Exporting a project report is grouped unless you ask for flat, while reading one is flat unless you ask for grouped. Pass <code>by_group</code> explicitly and the two agree.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="by_group = True pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.by_group)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.by_group">by_group</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="groups = None pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.groups)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.groups">groups</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_configs = None pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.analysis_configs)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.analysis_configs">analysis_configs</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="stratify_by = None pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.stratify_by)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.stratify_by">stratify_by</a></code> (<code><a class="autorefs autorefs-internal" title="MetadataType (yousleep_common.types.metadata.MetadataType)" href="../types/metadata/#yousleep_common.types.metadata.MetadataType">MetadataType</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="stratify_edges = None pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.stratify_edges)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.stratify_edges">stratify_edges</a></code> (<code><span title="list">list</span>[<span title="float">float</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="longitudinal = False pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.longitudinal)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.longitudinal">longitudinal</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="longitudinal_basis = None pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.longitudinal_basis)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.longitudinal_basis">longitudinal_basis</a></code> (<code><a class="autorefs autorefs-internal" title="LongitudinalBasis = Literal['session-index', 'calendar'] module-attribute (yousleep_common.models.longitudinal.LongitudinalBasis)" href="longitudinal/#yousleep_common.models.longitudinal.LongitudinalBasis">LongitudinalBasis</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subjects = None pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.subjects)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.subjects">subjects</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="calendar_granularity = 'month' pydantic-field (yousleep_common.models.report_export.ReportExportProjectParams.calendar_granularity)" href="report_export/#yousleep_common.models.report_export.ReportExportProjectParams.calendar_granularity">calendar_granularity</a></code> (<code><a class="autorefs autorefs-internal" title="CalendarGranularity = Literal['day', 'week', 'month'] module-attribute (yousleep_common.models.longitudinal.CalendarGranularity)" href="longitudinal/#yousleep_common.models.longitudinal.CalendarGranularity">CalendarGranularity</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.report_export.ReportExportProjectParams._validate_stratification">_validate_stratification</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.analysis_configs" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_configs</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.analysis_configs" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Only these analysis configurations contribute to the report; None includes every completed analysis. A report over one pipeline is the same report with the others left out — every count, card, figure and table follows the selection.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.by_group" class="doc doc-heading"> <code class="highlight language-python"><span class="n">by_group</span> <span class="o">=</span> <span class="kc">True</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.by_group" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Group statistics by study tags. Defaults to ON — the opposite of the by_group query parameter on GET /projects/{project}/report, which defaults to OFF. An export that omits this renders by-group over every tag; pass it explicitly rather than relying on either default.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.calendar_granularity" class="doc doc-heading"> <code class="highlight language-python"><span class="n">calendar_granularity</span> <span class="o">=</span> <span class="s1">'month'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.calendar_granularity" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The span of one bin on a 'calendar' basis; ignored otherwise.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.groups" class="doc doc-heading"> <code class="highlight language-python"><span class="n">groups</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.groups" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Tags forming the comparison groups; None = every tag.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.longitudinal" class="doc doc-heading"> <code class="highlight language-python"><span class="n">longitudinal</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.longitudinal" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Compute the longitudinal section (the flat boxplot with time bins as rows, one chart per metric) alongside the flat aggregates. Documents render it as an "Over time" block: the bins table and one figure per metric.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.longitudinal_basis" class="doc doc-heading"> <code class="highlight language-python"><span class="n">longitudinal_basis</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.longitudinal_basis" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the bins are; only meaningful with <code>longitudinal</code>. None lets the server choose: 'session-index' when any study in scope carries a subject key, else 'calendar'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.stratify_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">stratify_by</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.stratify_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stratify statistics by a subject-metadata factor instead of tags. When set, tag grouping is not applied (<code>by_group</code> is ignored) and <code>groups</code> must be omitted. Studies missing the factor form their own 'Not set' stratum.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.stratify_edges" class="doc doc-heading"> <code class="highlight language-python"><span class="n">stratify_edges</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.stratify_edges" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Bin edges overriding the server's configured defaults; numeric factors (age, bmi) only. Strictly increasing; bins are half-open intervals [a, b).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportExportProjectParams.subjects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subjects</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportExportProjectParams.subjects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Draw these subjects as lines beside the bins, one series each; only meaningful with <code>longitudinal</code>. Keys are compared case- and whitespace-insensitively, as grouping does.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportSection" class="doc doc-heading"> <code>ReportSection</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportSection" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One section of a report, in the order the report shows it.</p> <p>The report's composition is served with its content: the live page renders these sections and every export is built from the same list, so the two show the same sections, in the same order, with the same defaults. A section points at its content (a table in <code>tables</code>, a figure by its key and source) rather than repeating it.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.reports.ReportSection.key)" href="reports/#yousleep_common.models.reports.ReportSection.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="kind pydantic-field (yousleep_common.models.reports.ReportSection.kind)" href="reports/#yousleep_common.models.reports.ReportSection.kind">kind</a></code> (<code><span title="yousleep_common.models.reports.ReportSectionKind">ReportSectionKind</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="title = '' pydantic-field (yousleep_common.models.reports.ReportSection.title)" href="reports/#yousleep_common.models.reports.ReportSection.title">title</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="text = None pydantic-field (yousleep_common.models.reports.ReportSection.text)" href="reports/#yousleep_common.models.reports.ReportSection.text">text</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="parent = None pydantic-field (yousleep_common.models.reports.ReportSection.parent)" href="reports/#yousleep_common.models.reports.ReportSection.parent">parent</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="default_visible = True pydantic-field (yousleep_common.models.reports.ReportSection.default_visible)" href="reports/#yousleep_common.models.reports.ReportSection.default_visible">default_visible</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="table = None pydantic-field (yousleep_common.models.reports.ReportSection.table)" href="reports/#yousleep_common.models.reports.ReportSection.table">table</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="figure = None pydantic-field (yousleep_common.models.reports.ReportSection.figure)" href="reports/#yousleep_common.models.reports.ReportSection.figure">figure</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="figure_source = None pydantic-field (yousleep_common.models.reports.ReportSection.figure_source)" href="reports/#yousleep_common.models.reports.ReportSection.figure_source">figure_source</a></code> (<code><span title="yousleep_common.models.reports.ReportFigureSource">ReportFigureSource</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.default_visible" class="doc doc-heading"> <code class="highlight language-python"><span class="n">default_visible</span> <span class="o">=</span> <span class="kc">True</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.default_visible" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the section shows when the reader has not chosen. A per-analysis section a comparison already covers starts hidden.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.figure" class="doc doc-heading"> <code class="highlight language-python"><span class="n">figure</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.figure" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>For a 'figure' section: the key of its figure in the collection <code>figure_source</code> names.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.figure_source" class="doc doc-heading"> <code class="highlight language-python"><span class="n">figure_source</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.figure_source" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where the figure is: 'hypnogram' (<code>hypnograms</code>, keyed by analysis id), 'chart' (<code>charts</code>), 'longitudinal' (<code>longitudinal.charts</code>) or 'subject' (<code>longitudinal.subject_view.charts</code>).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable section identity, in the section-key vocabulary; what a layout entry names.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.kind" class="doc doc-heading"> <code class="highlight language-python"><span class="n">kind</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.kind" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>'text' (a sentence or two), 'heading' (groups the sections that name it as parent), 'table' or 'figure'.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.parent" class="doc doc-heading"> <code class="highlight language-python"><span class="n">parent</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.parent" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The key of the 'heading' section this one is grouped under; null at the top level.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.table" class="doc doc-heading"> <code class="highlight language-python"><span class="n">table</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.table" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>For a 'table' section: the key of its table in the response's <code>tables</code>.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.text" class="doc doc-heading"> <code class="highlight language-python"><span class="n">text</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.text" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The prose of a 'text' section, or the line under a heading's title; formatted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportSection.title" class="doc doc-heading"> <code class="highlight language-python"><span class="n">title</span> <span class="o">=</span> <span class="s1">''</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportSection.title" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The section's heading text.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ReportStratification" class="doc doc-heading"> <code>ReportStratification</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ReportStratification" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The stratification a report was computed with.</p> <p>Present on stratified reports only. Echoes the factor, the resolved bin edges and the per-stratum study counts, so consumers can caption the grouping instead of inferring it from labels.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="factor pydantic-field (yousleep_common.models.reports.ReportStratification.factor)" href="reports/#yousleep_common.models.reports.ReportStratification.factor">factor</a></code> (<code><a class="autorefs autorefs-internal" title="MetadataType (yousleep_common.types.MetadataType)" href="../types/#yousleep_common.types.MetadataType">MetadataType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="edges = None pydantic-field (yousleep_common.models.reports.ReportStratification.edges)" href="reports/#yousleep_common.models.reports.ReportStratification.edges">edges</a></code> (<code><span title="list">list</span>[<span title="float">float</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.reports.ReportStratification.unit)" href="reports/#yousleep_common.models.reports.ReportStratification.unit">unit</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="strata pydantic-field (yousleep_common.models.reports.ReportStratification.strata)" href="reports/#yousleep_common.models.reports.ReportStratification.strata">strata</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="StratumCount pydantic-model (yousleep_common.models.reports.StratumCount)" href="reports/#yousleep_common.models.reports.StratumCount">StratumCount</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportStratification.edges" class="doc doc-heading"> <code class="highlight language-python"><span class="n">edges</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportStratification.edges" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Resolved bin edges for numeric factors. Bins are half-open intervals [a, b): a value equal to an edge belongs to the bin above it. None for categorical factors (sex).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportStratification.factor" class="doc doc-heading"> <code class="highlight language-python"><span class="n">factor</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportStratification.factor" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The subject-metadata factor the report is stratified by.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportStratification.strata" class="doc doc-heading"> <code class="highlight language-python"><span class="n">strata</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportStratification.strata" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Every stratum in display order — edge order for numeric factors, enum order for sex — with the 'Not set' stratum last when present. Strata with zero studies are included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ReportStratification.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ReportStratification.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unit the edges are expressed in (e.g. 'years'); None for categorical factors.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ResetPasswordRequest" class="doc doc-heading"> <code>ResetPasswordRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ResetPasswordRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Set a new password with the token from a reset or setup link.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="password pydantic-field (yousleep_common.models.authentication.ResetPasswordRequest.password)" href="authentication/#yousleep_common.models.authentication.ResetPasswordRequest.password">password</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResetPasswordRequest.password" class="doc doc-heading"> <code class="highlight language-python"><span class="n">password</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResetPasswordRequest.password" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The new password. The server's password policy decides whether it is accepted.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ResolvedResourceClaim" class="doc doc-heading"> <code>ResolvedResourceClaim</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The resources one submission claims, resolved once, in canonical MiB.</p> <p>:class:<code>ResourceRequirements</code> carries the <em>coefficients</em>; this carries the numbers those coefficients produce for a particular submission's hours, channel count and native sample rate. Every field is a resolved quantity, not a rate.</p> <p>The claim is consumed twice, in different units: the container is <em>told</em> what to budget for itself (in MiB, in the manifest's <code>resources</code>), while the orchestrator <em>enforces</em> a ceiling (a cgroup, in MB). Both are rendered from this one resolved claim.</p> <p>The disk figure is kept only here, because the container is never given one.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="cpu_cores = None pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.cpu_cores)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.cpu_cores">cpu_cores</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="cpu_mhz = None pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.cpu_mhz)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.cpu_mhz">cpu_mhz</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="gpus = 0 pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.gpus)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.gpus">gpus</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="system_memory_mib pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.system_memory_mib)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.system_memory_mib">system_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="gpu_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.gpu_memory_mib)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.gpu_memory_mib">gpu_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="wall_clock_seconds = None pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.wall_clock_seconds)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.wall_clock_seconds">wall_clock_seconds</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="disk_mib pydantic-field (yousleep_common.models.analysis_submission.ResolvedResourceClaim.disk_mib)" href="analysis_submission/#yousleep_common.models.analysis_submission.ResolvedResourceClaim.disk_mib">disk_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_submission.ResolvedResourceClaim._one_cpu_unit">_one_cpu_unit</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.cpu_cores" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cpu_cores</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.cpu_cores" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whole CPU cores reserved for the run; rendered to the container as <code>--cpus</code> and the thread-count environment variables, and to the orchestrator as its CPU reservation. None only on claims persisted before the unit changed from MHz, which carry <code>cpu_mhz</code>.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.cpu_mhz" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cpu_mhz</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.cpu_mhz" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Legacy CPU floor in MHz on claims persisted before cores became the unit. Not written by current versions; read only to re-dispatch an old submission.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.disk_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">disk_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.disk_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Resolved disk in MiB — output artifacts plus the input files that must be materialised into the runtime. Never passed to the container, which is why this model exists.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.gpu_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">gpu_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.gpu_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Resolved peak GPU memory in MiB. 0 when no GPU is claimed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.gpus" class="doc doc-heading"> <code class="highlight language-python"><span class="n">gpus</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.gpus" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of GPUs claimed. 0 when the analysis runs on CPU.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">system_memory_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Resolved peak system memory in MiB. Rendered to the container as its memory hint and to the orchestrator as the cgroup ceiling; under-claiming this is what gets an analysis OOM-killed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResolvedResourceClaim.wall_clock_seconds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">wall_clock_seconds</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResolvedResourceClaim.wall_clock_seconds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How long this run may take before the platform stops it, resolved at submission from the platform's default for the recording's length and the configuration's ceiling, whichever is higher. None on a submission that predates the bound.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ResourceRequirements" class="doc doc-heading"> <code>ResourceRequirements</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Resource requirements for an analysis.</p> <p>Memory needs are a <strong>sum of optional linear terms</strong> (all but <code>base</code> default to 0, so each analysis opts into the terms matching how <em>it</em> loads and holds signal data — no analysis is forced into another's shape):</p> <div class="highlight"><pre><span></span><code>peak_memory_mib = base + per_hour * hours + per_hour_per_khz * hours * (max_sample_rate_hz / 1000) + per_hour_per_channel * hours * n_channels + per_hour_per_channel_per_khz * hours * n_channels * (max_sample_rate_hz / 1000) </code></pre></div> <p>The per-channel term captures data at the analysis's fixed <em>working</em> rate (one float32 full-signal copy at 128 Hz ~= 1.76 MiB/hour/channel); the per-kHz term captures data held at the recording's <em>native</em> rate (one float32 copy ~= 13.7 MiB/hour/channel/kHz) — e.g. the raw signal before an analysis downsamples it. <code>per_hour</code> is for channel-independent buffers; <code>per_hour_per_khz</code> for a channel-independent buffer at the native rate, such as the working memory of resampling one channel at a time, which every channel reuses.</p> <p>The api-server uses :meth:<code>estimate_peak_system_memory_mib</code> / :meth:<code>estimate_peak_gpu_memory_mib</code> at submission time to project the expected memory consumption and passes it to the orchestrator as the resource claim.</p> <p>CPU is claimed in whole cores: <code>cpu_cores</code> is the parallelism the analysis is written for. The platform reserves that many cores for the run, passes the same number to the container as <code>--cpus</code> and as the thread-count environment variables, and the container sizes its thread pools to it. Thread pools do not look at cgroups, so a container that starts more threads than it has cores is slower, not faster; the number here is what keeps a full queue from over-subscribing the host. There is no failure mode for too few cores, only a longer wall time, so no formula or per-tier cap is needed.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="cpu_cores pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.cpu_cores)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.cpu_cores">cpu_cores</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="base_system_memory_mib pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.base_system_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.base_system_memory_mib">base_system_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_system_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_system_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_system_memory_mib">per_hour_system_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_per_khz_system_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_khz_system_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_khz_system_memory_mib">per_hour_per_khz_system_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_per_channel_system_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_system_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_system_memory_mib">per_hour_per_channel_system_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_per_channel_per_khz_system_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_per_khz_system_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_per_khz_system_memory_mib">per_hour_per_channel_per_khz_system_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="base_gpu_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.base_gpu_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.base_gpu_memory_mib">base_gpu_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_gpu_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_gpu_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_gpu_memory_mib">per_hour_gpu_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_per_channel_gpu_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_gpu_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_gpu_memory_mib">per_hour_per_channel_gpu_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_per_channel_per_khz_gpu_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_per_khz_gpu_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_per_channel_per_khz_gpu_memory_mib">per_hour_per_channel_per_khz_gpu_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="artifacts_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.artifacts_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.artifacts_memory_mib">artifacts_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="per_hour_artifacts_memory_mib = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_artifacts_memory_mib)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.per_hour_artifacts_memory_mib">per_hour_artifacts_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="gpus = 0 pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.gpus)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.gpus">gpus</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="wall_clock = None pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.wall_clock)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.wall_clock">wall_clock</a></code> (<code><a class="autorefs autorefs-internal" title="WallClockCeiling pydantic-model (yousleep_common.models.analysis_config.resources.WallClockCeiling)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.WallClockCeiling">WallClockCeiling</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="gpu_required = False pydantic-field (yousleep_common.models.analysis_config.resources.ResourceRequirements.gpu_required)" href="analysis_config/resources/#yousleep_common.models.analysis_config.resources.ResourceRequirements.gpu_required">gpu_required</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_config.resources.ResourceRequirements._legacy_cpu_mhz">_legacy_cpu_mhz</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.artifacts_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">artifacts_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.artifacts_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Disk space (in MiB) reserved for output artifacts. Added to the size of any input recording files to determine the total disk requirement.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.base_gpu_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">base_gpu_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.base_gpu_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Constant term of the GPU-memory formula. Set to 0 if the analysis does not require a GPU.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.base_system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">base_system_memory_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.base_system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Constant term of the system-memory formula: covers fixed overhead (model weights, ONNX runtime, Python, preprocessing libraries) before any signal data is loaded.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.cpu_cores" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cpu_cores</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.cpu_cores" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whole CPU cores the analysis is written to use in parallel. Reserved for the run and passed to the container as <code>--cpus</code> and as the thread-count environment variables; size thread pools to it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.gpu_required" class="doc doc-heading"> <code class="highlight language-python"><span class="n">gpu_required</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.gpu_required" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether GPUs are mandatory or optional for the analysis.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.gpus" class="doc doc-heading"> <code class="highlight language-python"><span class="n">gpus</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.gpus" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The number of GPUs required for the analysis. Set to 0 if the analysis does not require a GPU.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_artifacts_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_artifacts_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_artifacts_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Disk space (in MiB) added per signal hour for output artifacts.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_gpu_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_gpu_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_gpu_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>GPU MiB per signal hour, independent of channel count. 0 if N/A.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_per_channel_gpu_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_per_channel_gpu_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_per_channel_gpu_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>GPU MiB per signal hour per selected channel (at the working rate). 0 if the analysis needs no GPU or its GPU memory doesn't scale with length x channels.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_per_channel_per_khz_gpu_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_per_channel_per_khz_gpu_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_per_channel_per_khz_gpu_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>GPU MiB per signal hour per channel per kHz of the native sample rate. 0 if the analysis doesn't hold native-rate signal on the GPU.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_per_channel_per_khz_system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_per_channel_per_khz_system_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_per_channel_per_khz_system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>System MiB per signal hour per channel per kHz of the recording's NATIVE sample rate — data held at native rate before downsampling (a float32 copy is ~13.7 MiB/h/ch/kHz). 0 if the analysis doesn't hold native-rate signal.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_per_channel_system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_per_channel_system_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_per_channel_system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>System MiB per signal hour per selected channel, at the analysis's fixed WORKING sample rate (a float32 full-signal copy at 128 Hz is ~1.76 MiB/h/ch). 0 if system memory does not scale with length x channels.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_per_khz_system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_per_khz_system_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_per_khz_system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>System MiB per signal hour per kHz of the recording's NATIVE sample rate, independent of channel count: a buffer at native rate that the channels use one at a time, such as the working memory of resampling. 0 if not applicable.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.per_hour_system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">per_hour_system_memory_mib</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.per_hour_system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>System MiB per signal hour, independent of channel count (e.g. a channel-independent results/accumulator buffer). 0 if not applicable.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceRequirements.wall_clock" class="doc doc-heading"> <code class="highlight language-python"><span class="n">wall_clock</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceRequirements.wall_clock" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A wall-clock ceiling raised above the platform's default, with the reason. A platform decision made at registration; an author leaves it out.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ResourceRequirements.estimate_peak_artifacts_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">estimate_peak_artifacts_memory_mib</span><span class="p">(</span><span class="n">hours</span><span class="p">)</span></code> <a href="#yousleep_common.models.ResourceRequirements.estimate_peak_artifacts_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Project disk space (in MiB) for output artifacts.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ResourceRequirements.estimate_peak_gpu_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">estimate_peak_gpu_memory_mib</span><span class="p">(</span><span class="n">hours</span><span class="p">,</span> <span class="n">n_channels</span><span class="p">,</span> <span class="n">max_sample_rate_hz</span><span class="p">)</span></code> <a href="#yousleep_common.models.ResourceRequirements.estimate_peak_gpu_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Project peak GPU memory in MiB for an analysis of the given size.</p> <p>Same optional-term structure as :meth:<code>estimate_peak_system_memory_mib</code>.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ResourceRequirements.estimate_peak_system_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">estimate_peak_system_memory_mib</span><span class="p">(</span><span class="n">hours</span><span class="p">,</span> <span class="n">n_channels</span><span class="p">,</span> <span class="n">max_sample_rate_hz</span><span class="p">)</span></code> <a href="#yousleep_common.models.ResourceRequirements.estimate_peak_system_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Project peak system memory in MiB for an analysis of the given size.</p> <p>Sum of the optional linear terms (see the class docstring): <code>base + per_hour*h + per_hour_per_khz*h*(max_sample_rate_hz/1000) + per_hour_per_channel*h*c + per_hour_per_channel_per_khz*h*c*(max_sample_rate_hz/1000)</code>.</p> <p><code>max_sample_rate_hz</code> is the maximum native sample rate across the selected channels (it only feeds the per-kHz terms). Rounded up so the orchestrator never gets a value below the projection.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ResourceRequirements.max_hours_within_system_memory" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_hours_within_system_memory</span><span class="p">(</span><span class="n">memory_mib</span><span class="p">,</span> <span class="n">n_channels</span><span class="p">,</span> <span class="n">max_sample_rate_hz</span><span class="p">)</span></code> <a href="#yousleep_common.models.ResourceRequirements.max_hours_within_system_memory" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the longest recording whose projected peak fits <code>memory_mib</code>.</p> <p>The inverse of :meth:<code>estimate_peak_system_memory_mib</code> for a given channel count and native rate: <code>(memory - base) / (the formula's per-hour slope)</code>. <code>None</code> when nothing scales with length, so any length fits once the base does; <code>0.0</code> when even the base does not fit.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ResourceUsage" class="doc doc-heading"> <code>ResourceUsage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ResourceUsage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Response model for the get_usage_stats endpoint.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="projects pydantic-field (yousleep_common.models.usage.ResourceUsage.projects)" href="usage/#yousleep_common.models.usage.ResourceUsage.projects">projects</a></code> (<code><a class="autorefs autorefs-internal" title="UsageCount pydantic-model (yousleep_common.models.usage.UsageCount)" href="usage/#yousleep_common.models.usage.UsageCount">UsageCount</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="studies pydantic-field (yousleep_common.models.usage.ResourceUsage.studies)" href="usage/#yousleep_common.models.usage.ResourceUsage.studies">studies</a></code> (<code><a class="autorefs autorefs-internal" title="UsageCount pydantic-model (yousleep_common.models.usage.UsageCount)" href="usage/#yousleep_common.models.usage.UsageCount">UsageCount</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recordings pydantic-field (yousleep_common.models.usage.ResourceUsage.recordings)" href="usage/#yousleep_common.models.usage.ResourceUsage.recordings">recordings</a></code> (<code><a class="autorefs autorefs-internal" title="UsageCount pydantic-model (yousleep_common.models.usage.UsageCount)" href="usage/#yousleep_common.models.usage.UsageCount">UsageCount</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses pydantic-field (yousleep_common.models.usage.ResourceUsage.analyses)" href="usage/#yousleep_common.models.usage.ResourceUsage.analyses">analyses</a></code> (<code><a class="autorefs autorefs-internal" title="UsageCount pydantic-model (yousleep_common.models.usage.UsageCount)" href="usage/#yousleep_common.models.usage.UsageCount">UsageCount</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reports pydantic-field (yousleep_common.models.usage.ResourceUsage.reports)" href="usage/#yousleep_common.models.usage.ResourceUsage.reports">reports</a></code> (<code><a class="autorefs autorefs-internal" title="UsageCount pydantic-model (yousleep_common.models.usage.UsageCount)" href="usage/#yousleep_common.models.usage.UsageCount">UsageCount</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_hours pydantic-field (yousleep_common.models.usage.ResourceUsage.analysis_hours)" href="usage/#yousleep_common.models.usage.ResourceUsage.analysis_hours">analysis_hours</a></code> (<code><a class="autorefs autorefs-internal" title="UsageHours pydantic-model (yousleep_common.models.usage.UsageHours)" href="usage/#yousleep_common.models.usage.UsageHours">UsageHours</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage pydantic-field (yousleep_common.models.usage.ResourceUsage.storage)" href="usage/#yousleep_common.models.usage.ResourceUsage.storage">storage</a></code> (<code><a class="autorefs autorefs-internal" title="UsageBytes pydantic-model (yousleep_common.models.usage.UsageBytes)" href="usage/#yousleep_common.models.usage.UsageBytes">UsageBytes</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.analyses" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.analyses" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The total number of analyses created by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.analysis_hours" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_hours</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.analysis_hours" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Analysis hours usage information.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.projects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">projects</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.projects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The total number of projects created by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.recordings" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recordings</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.recordings" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The total number of recordings created by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.reports" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reports</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.reports" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The total number of reports created by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.storage" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.storage" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Storage usage information.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResourceUsage.studies" class="doc doc-heading"> <code class="highlight language-python"><span class="n">studies</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResourceUsage.studies" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The total number of studies created by the user.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ResourceUsage.is_within_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">is_within_limit</span><span class="p">(</span><span class="n">limit</span><span class="p">)</span></code> <a href="#yousleep_common.models.ResourceUsage.is_within_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Check if the usage represented by this model is within a set of usage limits.</p> <p>Calls the is_within_limit method on each of the UsageBase fields in this model and returns True if all of them return True and False otherwise. Also returns a list of field names indicating which limits are exceeded if any.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ResultAttestations" class="doc doc-heading"> <code>ResultAttestations</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ResultAttestations" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What ran, on what, as the runner states it.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.ResultAttestations.image_digest">image_digest</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.ResultAttestations.input_sha256">input_sha256</span></code> (<code><span title="list">list</span>[<span title="typing.Annotated">Annotated</span>[<span title="str">str</span>, <span title="pydantic.Field">Field</span>(pattern=<span title="yousleep_common.models.runner._SHA256_HEX">_SHA256_HEX</span>)]]</code>) </li> <li> <code><span title="yousleep_common.models.runner.ResultAttestations.runner_version">runner_version</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="input_sizes = None pydantic-field (yousleep_common.models.runner.ResultAttestations.input_sizes)" href="runner/#yousleep_common.models.runner.ResultAttestations.input_sizes">input_sizes</a></code> (<code><span title="list">list</span>[<span title="typing.Annotated">Annotated</span>[<span title="int">int</span>, <span title="pydantic.Field">Field</span>(ge=0)]] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="input_etags = None pydantic-field (yousleep_common.models.runner.ResultAttestations.input_etags)" href="runner/#yousleep_common.models.runner.ResultAttestations.input_etags">input_etags</a></code> (<code><span title="list">list</span>[<span title="typing.Annotated">Annotated</span>[<span title="str">str</span>, <span title="pydantic.Field">Field</span>(max_length=256)] | None] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResultAttestations.input_etags" class="doc doc-heading"> <code class="highlight language-python"><span class="n">input_etags</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResultAttestations.input_etags" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Each input's ETag as its storage answered the fetch, in the order of <code>input_sha256</code>, or null where it gave none. Older runners leave it out.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ResultAttestations.input_sizes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">input_sizes</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ResultAttestations.input_sizes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Each input's size in bytes as fetched, in the order of <code>input_sha256</code>. Older runners leave it out.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunPlacement" class="doc doc-heading"> <code>RunPlacement</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunPlacement" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Where a submission would run, and what that does to its price.</p> <p>Every analysis of an organisation runs in one place, set for the organisation: on the platform, or at its site.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="place pydantic-field (yousleep_common.models.billing.RunPlacement.place)" href="billing/#yousleep_common.models.billing.RunPlacement.place">place</a></code> (<code><a class="autorefs autorefs-internal" title="RunPlace (yousleep_common.types.RunPlace)" href="../types/#yousleep_common.types.RunPlace">RunPlace</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="site_factor = None pydantic-field (yousleep_common.models.billing.RunPlacement.site_factor)" href="billing/#yousleep_common.models.billing.RunPlacement.site_factor">site_factor</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="runner_seen pydantic-field (yousleep_common.models.billing.RunPlacement.runner_seen)" href="billing/#yousleep_common.models.billing.RunPlacement.runner_seen">runner_seen</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.billing.RunPlacement._a_factor_only_at_a_site">_a_factor_only_at_a_site</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunPlacement.place" class="doc doc-heading"> <code class="highlight language-python"><span class="n">place</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunPlacement.place" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>On the platform, or at the organisation's own site.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunPlacement.runner_seen" class="doc doc-heading"> <code class="highlight language-python"><span class="n">runner_seen</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunPlacement.runner_seen" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether a runner of the place's pool asked for work in the last three minutes. While none has, a submission waits in the queue, and is withdrawn after the queue timeout.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunPlacement.site_factor" class="doc doc-heading"> <code class="highlight language-python"><span class="n">site_factor</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunPlacement.site_factor" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The factor on the platform price the quoted credits include, for a run at the site; null on the platform.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunRecordListResponse" class="doc doc-heading"> <code>RunRecordListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunRecordListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of run records, newest first.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.runner.RunRecordListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.runner.RunRecordListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.runner.RunRecordListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordListResponse.items">items</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="RunRecordOut pydantic-model (yousleep_common.models.runner.RunRecordOut)" href="runner/#yousleep_common.models.runner.RunRecordOut">RunRecordOut</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunRecordOut" class="doc doc-heading"> <code>RunRecordOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunRecordOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Where a job ran and on what, as its runner attested it.</p> <p>One per accepted result, of every kind of job. It names the job's subject as its lease did: the analysis an analysis ran, the recording an ingest read, or the object a delete removed from an organisation's bucket, and that bucket's storage location.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.kind">kind</span></code> (<code><a class="autorefs autorefs-internal" title="LeaseKind (yousleep_common.types.runner.LeaseKind)" href="../types/runner/#yousleep_common.types.runner.LeaseKind">LeaseKind</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_id = None pydantic-field (yousleep_common.models.runner.RunRecordOut.analysis_id)" href="runner/#yousleep_common.models.runner.RunRecordOut.analysis_id">analysis_id</a></code> (<code><span title="pydantic.UUID7">UUID7</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_id = None pydantic-field (yousleep_common.models.runner.RunRecordOut.recording_id)" href="runner/#yousleep_common.models.runner.RunRecordOut.recording_id">recording_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="object_url = None pydantic-field (yousleep_common.models.runner.RunRecordOut.object_url)" href="runner/#yousleep_common.models.runner.RunRecordOut.object_url">object_url</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_location_id = None pydantic-field (yousleep_common.models.runner.RunRecordOut.storage_location_id)" href="runner/#yousleep_common.models.runner.RunRecordOut.storage_location_id">storage_location_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.lease_id">lease_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.pool_id">pool_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.runner_id">runner_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.runner_version">runner_version</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="image_digest pydantic-field (yousleep_common.models.runner.RunRecordOut.image_digest)" href="runner/#yousleep_common.models.runner.RunRecordOut.image_digest">image_digest</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="input_sha256 pydantic-field (yousleep_common.models.runner.RunRecordOut.input_sha256)" href="runner/#yousleep_common.models.runner.RunRecordOut.input_sha256">input_sha256</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="output_sha256 pydantic-field (yousleep_common.models.runner.RunRecordOut.output_sha256)" href="runner/#yousleep_common.models.runner.RunRecordOut.output_sha256">output_sha256</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="peak_memory_mib pydantic-field (yousleep_common.models.runner.RunRecordOut.peak_memory_mib)" href="runner/#yousleep_common.models.runner.RunRecordOut.peak_memory_mib">peak_memory_mib</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.duration_seconds">duration_seconds</span></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.RunRecordOut.recorded_at">recorded_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.analysis_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.analysis_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>An analysis's.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.image_digest" class="doc doc-heading"> <code class="highlight language-python"><span class="n">image_digest</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.image_digest" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The digest of the image that ran, as the runner pulled it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.input_sha256" class="doc doc-heading"> <code class="highlight language-python"><span class="n">input_sha256</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.input_sha256" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The inputs, as the runner read them.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.object_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">object_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.object_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A delete's.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.output_sha256" class="doc doc-heading"> <code class="highlight language-python"><span class="n">output_sha256</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.output_sha256" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The document the job uploaded, as the platform read it: an analysis's events, an ingest's reading.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.peak_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">peak_memory_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.peak_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The container's peak memory, as it recorded it on exit.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.recording_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.recording_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>An ingest's.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunRecordOut.storage_location_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_location_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunRecordOut.storage_location_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A delete's.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunnerApproveRequest" class="doc doc-heading"> <code>RunnerApproveRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunnerApproveRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Approve a pending runner.</p> <p>The fingerprint is the one the administrator compared with the runner's host. The platform refuses the approval when it differs from the enrolled key's, so an approval cannot land on another runner by mistake.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunnerApproveRequest.fingerprint">fingerprint</span></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunnerCapacity" class="doc doc-heading"> <code>RunnerCapacity</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunnerCapacity" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Room on a runner: cores and memory.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunnerCapacity.cores">cores</span></code> (<code><span title="float">float</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerCapacity.memory_mib">memory_mib</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunnerEnrolRequest" class="doc doc-heading"> <code>RunnerEnrolRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunnerEnrolRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What a runner sends to enrol. The request is signed with the new key.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunnerEnrolRequest.token">token</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.runner.RunnerEnrolRequest.name)" href="runner/#yousleep_common.models.runner.RunnerEnrolRequest.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="public_key pydantic-field (yousleep_common.models.runner.RunnerEnrolRequest.public_key)" href="runner/#yousleep_common.models.runner.RunnerEnrolRequest.public_key">public_key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerEnrolRequest.version">version</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerEnrolRequest.capacity">capacity</span></code> (<code><a class="autorefs autorefs-internal" title="RunnerCapacity pydantic-model (yousleep_common.models.runner.RunnerCapacity)" href="runner/#yousleep_common.models.runner.RunnerCapacity">RunnerCapacity</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunnerEnrolRequest._is_an_ed25519_key">_is_an_ed25519_key</span></code> → <code><a class="autorefs autorefs-internal" title="public_key pydantic-field (yousleep_common.models.runner.RunnerEnrolRequest.public_key)" href="runner/#yousleep_common.models.runner.RunnerEnrolRequest.public_key">public_key</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerEnrolRequest.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerEnrolRequest.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>A label for the host, chosen at install.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerEnrolRequest.public_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">public_key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerEnrolRequest.public_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The runner's Ed25519 public key: 32 raw bytes, base64.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunnerEnrolResponse" class="doc doc-heading"> <code>RunnerEnrolResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunnerEnrolResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The enrolled runner, as it asks after itself.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunnerEnrolResponse.runner_id">runner_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerEnrolResponse.state">state</span></code> (<code><a class="autorefs autorefs-internal" title="RunnerState (yousleep_common.types.runner.RunnerState)" href="../types/runner/#yousleep_common.types.runner.RunnerState">RunnerState</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="fingerprint pydantic-field (yousleep_common.models.runner.RunnerEnrolResponse.fingerprint)" href="runner/#yousleep_common.models.runner.RunnerEnrolResponse.fingerprint">fingerprint</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerEnrolResponse.fingerprint" class="doc doc-heading"> <code class="highlight language-python"><span class="n">fingerprint</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerEnrolResponse.fingerprint" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The runner key's fingerprint, as the platform computed it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunnerListResponse" class="doc doc-heading"> <code>RunnerListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunnerListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of runners, and what applies to every runner.</p> <p>The page answers before a pool has its first runner, so it carries the runner image a new runner installs: an install command can be shown before any enrolment token exists.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.runner.RunnerListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.runner.RunnerListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.runner.RunnerListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerListResponse.items">items</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="RunnerOut pydantic-model (yousleep_common.models.runner.RunnerOut)" href="runner/#yousleep_common.models.runner.RunnerOut">RunnerOut</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="quarantine_after_failures pydantic-field (yousleep_common.models.runner.RunnerListResponse.quarantine_after_failures)" href="runner/#yousleep_common.models.runner.RunnerListResponse.quarantine_after_failures">quarantine_after_failures</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerListResponse.runner_image">runner_image</span></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerListResponse.quarantine_after_failures" class="doc doc-heading"> <code class="highlight language-python"><span class="n">quarantine_after_failures</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerListResponse.quarantine_after_failures" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Failures in a row that quarantine a runner.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.RunnerOut" class="doc doc-heading"> <code>RunnerOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.RunnerOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A runner as administrators see it.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.RunnerOut.id">id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.pool_id">pool_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.name">name</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.state">state</span></code> (<code><a class="autorefs autorefs-internal" title="RunnerState (yousleep_common.types.runner.RunnerState)" href="../types/runner/#yousleep_common.types.runner.RunnerState">RunnerState</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="fingerprint_hint pydantic-field (yousleep_common.models.runner.RunnerOut.fingerprint_hint)" href="runner/#yousleep_common.models.runner.RunnerOut.fingerprint_hint">fingerprint_hint</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.version">version</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.capacity">capacity</span></code> (<code><a class="autorefs autorefs-internal" title="RunnerCapacity pydantic-model (yousleep_common.models.runner.RunnerCapacity)" href="runner/#yousleep_common.models.runner.RunnerCapacity">RunnerCapacity</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="held pydantic-field (yousleep_common.models.runner.RunnerOut.held)" href="runner/#yousleep_common.models.runner.RunnerOut.held">held</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="booked_cores pydantic-field (yousleep_common.models.runner.RunnerOut.booked_cores)" href="runner/#yousleep_common.models.runner.RunnerOut.booked_cores">booked_cores</a></code> (<code><span title="pydantic.NonNegativeFloat">NonNegativeFloat</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="booked_memory_mib pydantic-field (yousleep_common.models.runner.RunnerOut.booked_memory_mib)" href="runner/#yousleep_common.models.runner.RunnerOut.booked_memory_mib">booked_memory_mib</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="failures_in_a_row pydantic-field (yousleep_common.models.runner.RunnerOut.failures_in_a_row)" href="runner/#yousleep_common.models.runner.RunnerOut.failures_in_a_row">failures_in_a_row</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.quarantined_at">quarantined_at</span></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.last_seen_at">last_seen_at</span></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="taking_work = False pydantic-field (yousleep_common.models.runner.RunnerOut.taking_work)" href="runner/#yousleep_common.models.runner.RunnerOut.taking_work">taking_work</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.created_at">created_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.approved_at">approved_at</span></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.runner.RunnerOut.revoked_at">revoked_at</span></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerOut.booked_cores" class="doc doc-heading"> <code class="highlight language-python"><span class="n">booked_cores</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerOut.booked_cores" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Cores its held jobs book, out of its capacity's cores.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerOut.booked_memory_mib" class="doc doc-heading"> <code class="highlight language-python"><span class="n">booked_memory_mib</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerOut.booked_memory_mib" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Memory its held jobs book, out of its capacity's memory.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerOut.failures_in_a_row" class="doc doc-heading"> <code class="highlight language-python"><span class="n">failures_in_a_row</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerOut.failures_in_a_row" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Jobs given back in a row, on their first try, for a fault that points at the runner's host: an image that would not pull or verify, an input that would not download, or an error from the container runtime. A job given back for another reason, such as an image the registry says it does not have, leaves it as it is; any other result resets it. At the limit in the list's <code>quarantine_after_failures</code> the runner is quarantined.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerOut.fingerprint_hint" class="doc doc-heading"> <code class="highlight language-python"><span class="n">fingerprint_hint</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerOut.fingerprint_hint" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The last characters of the key's fingerprint. Approval needs the whole fingerprint, read on the runner's host.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerOut.held" class="doc doc-heading"> <code class="highlight language-python"><span class="n">held</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerOut.held" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Jobs the runner holds now, starting or running.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.RunnerOut.taking_work" class="doc doc-heading"> <code class="highlight language-python"><span class="n">taking_work</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.RunnerOut.taking_work" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the platform counts the runner as taking work: it is approved, not quarantined, and asked for work in the last three minutes. False from a server that predates it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SectionLayoutEntry" class="doc doc-heading"> <code>SectionLayoutEntry</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SectionLayoutEntry" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One section of the user-configurable report layout.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.report_export.SectionLayoutEntry.key)" href="report_export/#yousleep_common.models.report_export.SectionLayoutEntry.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="visible pydantic-field (yousleep_common.models.report_export.SectionLayoutEntry.visible)" href="report_export/#yousleep_common.models.report_export.SectionLayoutEntry.visible">visible</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="columns = None pydantic-field (yousleep_common.models.report_export.SectionLayoutEntry.columns)" href="report_export/#yousleep_common.models.report_export.SectionLayoutEntry.columns">columns</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SectionLayoutEntry.columns" class="doc doc-heading"> <code class="highlight language-python"><span class="n">columns</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SectionLayoutEntry.columns" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The stored selection for this entry: COLUMN keys for event/project stats tables, ROW (metric) keys for biomarker and biomarker-summary tables (their curated set is rows), and row/series names for chart entries. None = the curated default set. Carried in the layout document, so exports honor the page's selection.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SectionLayoutEntry.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SectionLayoutEntry.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The layout document holds two entry kinds. SECTION entries name a key of the report's served sections (the SECTION_KEY_<em>/SECTION_PREFIX_</em> vocabulary in this module), such as 'statistics-window', 'hypnogram:{analysis_id}', 'event-stats:{analysis_id}', 'family-comparison:{family}' or 'stats-card:{config_id}'. A figure section ('chart:{chart_key}') also carries which of its rows show. PRESENTATION entries carry a selection but name no section: 'chart-groups' (the group-legend series filter). Keys a renderer does not know are ignored; a section the layout does not mention takes its served default visibility.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SectionLayoutEntry.visible" class="doc doc-heading"> <code class="highlight language-python"><span class="n">visible</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SectionLayoutEntry.visible" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the section appears in the report.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ServerApiKeyLimits" class="doc doc-heading"> <code>ServerApiKeyLimits</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ServerApiKeyLimits" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The API-key policy a deployment enforces, for clients that create keys.</p> <p>All zero means the server did not report it (older API).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="max_ttl_days = 0 pydantic-field (yousleep_common.models.api_server.ServerApiKeyLimits.max_ttl_days)" href="api_server/#yousleep_common.models.api_server.ServerApiKeyLimits.max_ttl_days">max_ttl_days</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="default_ttl_days = 0 pydantic-field (yousleep_common.models.api_server.ServerApiKeyLimits.default_ttl_days)" href="api_server/#yousleep_common.models.api_server.ServerApiKeyLimits.default_ttl_days">default_ttl_days</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_active_per_user = 0 pydantic-field (yousleep_common.models.api_server.ServerApiKeyLimits.max_active_per_user)" href="api_server/#yousleep_common.models.api_server.ServerApiKeyLimits.max_active_per_user">max_active_per_user</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerApiKeyLimits.default_ttl_days" class="doc doc-heading"> <code class="highlight language-python"><span class="n">default_ttl_days</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerApiKeyLimits.default_ttl_days" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The lifetime applied when a request omits <code>expires_in_days</code>.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerApiKeyLimits.max_active_per_user" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_active_per_user</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerApiKeyLimits.max_active_per_user" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many unexpired keys one account may hold at once.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerApiKeyLimits.max_ttl_days" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_ttl_days</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerApiKeyLimits.max_ttl_days" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The longest lifetime a key may be created with.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ServerBatchLimits" class="doc doc-heading"> <code>ServerBatchLimits</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Maximum item counts accepted by the batch endpoints, per request.</p> <p>The same numbers the request schemas state as <code>maxItems</code>, served so a client can read them at runtime without parsing the schema; the server enforces exactly these.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="max_analysis_submissions pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_analysis_submissions)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_analysis_submissions">max_analysis_submissions</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_studies pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_studies)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_studies">max_studies</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_event_analysis_ids pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_event_analysis_ids)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_event_analysis_ids">max_event_analysis_ids</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_cancel_analysis_ids pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_cancel_analysis_ids)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_cancel_analysis_ids">max_cancel_analysis_ids</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_analysis_status_ids pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_analysis_status_ids)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_analysis_status_ids">max_analysis_status_ids</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_recording_detail_ids pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_recording_detail_ids)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_recording_detail_ids">max_recording_detail_ids</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_recordings_by_study_ids pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_recordings_by_study_ids)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_recordings_by_study_ids">max_recordings_by_study_ids</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_study_ids pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_study_ids)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_study_ids">max_study_ids</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_channel_patches pydantic-field (yousleep_common.models.api_server.ServerBatchLimits.max_channel_patches)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits.max_channel_patches">max_channel_patches</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_analysis_status_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_analysis_status_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_analysis_status_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max analysis IDs in one batch status poll</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_analysis_submissions" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_analysis_submissions</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_analysis_submissions" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max targets × pipeline steps in one batch analysis submission</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_cancel_analysis_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_cancel_analysis_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_cancel_analysis_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max analysis IDs in one batch cancellation</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_channel_patches" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_channel_patches</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_channel_patches" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max patches in one bulk channel patch</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_event_analysis_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_event_analysis_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_event_analysis_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max analysis IDs in one batch event retrieval</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_recording_detail_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_recording_detail_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_recording_detail_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max recording IDs in one batch details retrieval</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_recordings_by_study_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_recordings_by_study_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_recordings_by_study_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max study IDs in one batch recordings-by-study retrieval</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_studies" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_studies</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_studies" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max studies in one batch study creation</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerBatchLimits.max_study_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_study_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.max_study_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Max study IDs in one batch studies-by-id retrieval</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.ServerBatchLimits.contract" class="doc doc-heading"> <code class="highlight language-python"><span class="n">contract</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-classmethod"><code>classmethod</code></small> </span> <a href="#yousleep_common.models.ServerBatchLimits.contract" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return the caps as the request schemas state them.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ServerFeaturesEnabled" class="doc doc-heading"> <code>ServerFeaturesEnabled</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Global server features that are enabled or disabled.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="login pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.login)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.login">login</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="registration pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.registration)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.registration">registration</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="require_approval pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.require_approval)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.require_approval">require_approval</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="selectable_usage_types pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.selectable_usage_types)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.selectable_usage_types">selectable_usage_types</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="UsageType (yousleep_common.types.UsageType)" href="../types/#yousleep_common.types.UsageType">UsageType</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="assignable_usage_types pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.assignable_usage_types)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.assignable_usage_types">assignable_usage_types</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="UsageType (yousleep_common.types.UsageType)" href="../types/#yousleep_common.types.UsageType">UsageType</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email_verification pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.email_verification)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.email_verification">email_verification</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="demo_datasets pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.demo_datasets)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.demo_datasets">demo_datasets</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="uploads = True pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.uploads)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.uploads">uploads</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="submissions = True pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.submissions)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.submissions">submissions</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="password_policy pydantic-field (yousleep_common.models.api_server.ServerFeaturesEnabled.password_policy)" href="api_server/#yousleep_common.models.api_server.ServerFeaturesEnabled.password_policy">password_policy</a></code> (<code><a class="autorefs autorefs-internal" title="PasswordPolicy pydantic-model (yousleep_common.models.api_server.PasswordPolicy)" href="api_server/#yousleep_common.models.api_server.PasswordPolicy">PasswordPolicy</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.assignable_usage_types" class="doc doc-heading"> <code class="highlight language-python"><span class="n">assignable_usage_types</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.assignable_usage_types" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Usage types that may be held by a user AT ALL, admins included — a superset of <code>selectable_usage_types</code>. Derived, not configured: a usage type is assignable only if a LICENCE DOCUMENT exists for it, because holding one means being gated onto that licence. CLINICAL is absent until a clinical licence is published. Admin UIs should offer exactly this list.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.demo_datasets" class="doc doc-heading"> <code class="highlight language-python"><span class="n">demo_datasets</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.demo_datasets" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether demo dataset registration is available (requires local storage backend)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.email_verification" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email_verification</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.email_verification" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether email verification is enabled</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.login" class="doc doc-heading"> <code class="highlight language-python"><span class="n">login</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.login" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether user login is enabled</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.password_policy" class="doc doc-heading"> <code class="highlight language-python"><span class="n">password_policy</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.password_policy" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The password length policy the server enforces at registration — clients should validate/hint against these bounds rather than hardcoding them.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.registration" class="doc doc-heading"> <code class="highlight language-python"><span class="n">registration</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.registration" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether user registration is enabled</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.require_approval" class="doc doc-heading"> <code class="highlight language-python"><span class="n">require_approval</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.require_approval" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether self-registrations require admin approval before login (request-access mode). When true, the client should frame sign-up as 'request access' and tell the user their account is pending after registering.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.selectable_usage_types" class="doc doc-heading"> <code class="highlight language-python"><span class="n">selectable_usage_types</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.selectable_usage_types" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Usage types a REGISTRANT may currently choose. A policy list — narrower than what may exist at all (see <code>assignable_usage_types</code>), e.g. COMMERCIAL is withheld from sign-up while it is offered by arrangement only. The client should grey out any UsageType not in this list; the server also rejects them.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.submissions" class="doc doc-heading"> <code class="highlight language-python"><span class="n">submissions</span> <span class="o">=</span> <span class="kc">True</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.submissions" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether analyses may be submitted right now. As for <code>uploads</code>: a bounded, operator-set suspension, reported here so the submit surfaces can say so.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerFeaturesEnabled.uploads" class="doc doc-heading"> <code class="highlight language-python"><span class="n">uploads</span> <span class="o">=</span> <span class="kc">True</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerFeaturesEnabled.uploads" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether recordings may be registered right now. An operator may suspend uploads platform-wide for a bounded time; a client that reads false should say so instead of offering the upload and expecting a refusal.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ServerLimits" class="doc doc-heading"> <code>ServerLimits</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ServerLimits" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Server request limits relevant to clients.</p> <p>The batch caps are contract constants (the request schemas' <code>maxItems</code>); the upload ceilings are deployment configuration. Both are distinct from per-user usage quotas, which are exposed via <code>/history/usage/limits</code>.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="batch pydantic-field (yousleep_common.models.api_server.ServerLimits.batch)" href="api_server/#yousleep_common.models.api_server.ServerLimits.batch">batch</a></code> (<code><a class="autorefs autorefs-internal" title="ServerBatchLimits pydantic-model (yousleep_common.models.api_server.ServerBatchLimits)" href="api_server/#yousleep_common.models.api_server.ServerBatchLimits">ServerBatchLimits</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="max_upload_bytes pydantic-field (yousleep_common.models.api_server.ServerLimits.max_upload_bytes)" href="api_server/#yousleep_common.models.api_server.ServerLimits.max_upload_bytes">max_upload_bytes</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="api_keys pydantic-field (yousleep_common.models.api_server.ServerLimits.api_keys)" href="api_server/#yousleep_common.models.api_server.ServerLimits.api_keys">api_keys</a></code> (<code><a class="autorefs autorefs-internal" title="ServerApiKeyLimits pydantic-model (yousleep_common.models.api_server.ServerApiKeyLimits)" href="api_server/#yousleep_common.models.api_server.ServerApiKeyLimits">ServerApiKeyLimits</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_formats pydantic-field (yousleep_common.models.api_server.ServerLimits.recording_formats)" href="api_server/#yousleep_common.models.api_server.ServerLimits.recording_formats">recording_formats</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="FileFormat (yousleep_common.types.FileFormat)" href="../types/#yousleep_common.types.FileFormat">FileFormat</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerLimits.api_keys" class="doc doc-heading"> <code class="highlight language-python"><span class="n">api_keys</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerLimits.api_keys" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The API-key lifetime and count policy in force.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerLimits.batch" class="doc doc-heading"> <code class="highlight language-python"><span class="n">batch</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerLimits.batch" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-request item caps for the batch endpoints</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerLimits.max_upload_bytes" class="doc doc-heading"> <code class="highlight language-python"><span class="n">max_upload_bytes</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerLimits.max_upload_bytes" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Maximum size (bytes) of a single recording (register -> presigned PUT -> finalize). Clients should validate against this rather than hardcoding a cap a config change could invalidate.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerLimits.recording_formats" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_formats</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerLimits.recording_formats" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The formats a recording may be uploaded in, matched on the file extension (the format's value, e.g. <code>edf</code>). Filter a file picker and validate against this rather than hardcoding a list; the server refuses any other format at registration.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.ServerVersionInfo" class="doc doc-heading"> <code>ServerVersionInfo</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.ServerVersionInfo" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Server version information.</p> <p>Contains version information for the API server and common module.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="api_version pydantic-field (yousleep_common.models.version.ServerVersionInfo.api_version)" href="version/#yousleep_common.models.version.ServerVersionInfo.api_version">api_version</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="common_version pydantic-field (yousleep_common.models.version.ServerVersionInfo.common_version)" href="version/#yousleep_common.models.version.ServerVersionInfo.common_version">common_version</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerVersionInfo.api_version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">api_version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerVersionInfo.api_version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Version of the API server</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.ServerVersionInfo.common_version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">common_version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.ServerVersionInfo.common_version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Version of the yousleep_common module used by the API</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SignalWindow" class="doc doc-heading"> <code>SignalWindow</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SignalWindow" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Signal window model.</p> <p>Represents a window of time in a signal with an offset start and end time relative to the beginning of the recording. Can be used to specify a subset of a signal or events in a signal.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="window_start_time_ms = 0 pydantic-field (yousleep_common.models.channel.SignalWindow.window_start_time_ms)" href="channel/#yousleep_common.models.channel.SignalWindow.window_start_time_ms">window_start_time_ms</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="window_end_time_ms = None pydantic-field (yousleep_common.models.channel.SignalWindow.window_end_time_ms)" href="channel/#yousleep_common.models.channel.SignalWindow.window_end_time_ms">window_end_time_ms</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_time_order() pydantic-validator (yousleep_common.models.channel.SignalWindow.validate_time_order)" href="channel/#yousleep_common.models.channel.SignalWindow.validate_time_order">validate_time_order</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SignalWindow.duration_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">duration_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.SignalWindow.duration_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Calculate the duration of the signal in milliseconds.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SignalWindow.window_end_time_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">window_end_time_ms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SignalWindow.window_end_time_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>End of the signal in milliseconds relative to the beggining of the recording. Defaults None indicating to the end of the recording if not specified.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SignalWindow.window_start_time_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">window_start_time_ms</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SignalWindow.window_start_time_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Start of the signal in milliseconds relative to the beggining of the recording. Defaults to 0 if not specified.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.SignalWindow.__hash__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__hash__</span><span class="p">()</span></code> <a href="#yousleep_common.models.SignalWindow.__hash__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Hash by JSON serialisation (:func:<code>_json_hash</code>).</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.SignalWindow.validate_time_order" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_time_order</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.SignalWindow.validate_time_order" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that start time is less than end time.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteAgreementAccept" class="doc doc-heading"> <code>SiteAgreementAccept</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteAgreementAccept" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The owner's acceptance of the site agreement, at the version they read.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.site_capabilities.SiteAgreementAccept.version)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteAgreementAccept.version">version</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAgreementAccept.version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAgreementAccept.version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The version accepted; it must be the latest published one.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteAgreementAcceptance" class="doc doc-heading"> <code>SiteAgreementAcceptance</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteAgreementAcceptance" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An acceptance of the site agreement, as recorded.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.SiteAgreementAcceptance.org_id">org_id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="version pydantic-field (yousleep_common.models.site_capabilities.SiteAgreementAcceptance.version)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteAgreementAcceptance.version">version</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="accepted_by = None pydantic-field (yousleep_common.models.site_capabilities.SiteAgreementAcceptance.accepted_by)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteAgreementAcceptance.accepted_by">accepted_by</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.SiteAgreementAcceptance.accepted_by_name">accepted_by_name</span></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.SiteAgreementAcceptance.accepted_at">accepted_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAgreementAcceptance.accepted_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">accepted_by</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAgreementAcceptance.accepted_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Who accepted it, on the organisation's behalf; None once that account is gone.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAgreementAcceptance.version" class="doc doc-heading"> <code class="highlight language-python"><span class="n">version</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAgreementAcceptance.version" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The version accepted.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteAllowance" class="doc doc-heading"> <code>SiteAllowance</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteAllowance" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Where the caller's organisation may run an analysis.</p> <p>The platform runs every analysis. An organisation's own site runs one whose configuration allows a site, or one that an exception in force covers for the organisation. The quote and the submission apply the same rule; this says what it gives before either is asked.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="place pydantic-field (yousleep_common.models.analysis_config.config.SiteAllowance.place)" href="analysis_config/config/#yousleep_common.models.analysis_config.config.SiteAllowance.place">place</a></code> (<code><a class="autorefs autorefs-internal" title="RunPlace (yousleep_common.types.sites.RunPlace)" href="../types/sites/#yousleep_common.types.sites.RunPlace">RunPlace</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="runs_there pydantic-field (yousleep_common.models.analysis_config.config.SiteAllowance.runs_there)" href="analysis_config/config/#yousleep_common.models.analysis_config.config.SiteAllowance.runs_there">runs_there</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="allowed_at_site pydantic-field (yousleep_common.models.analysis_config.config.SiteAllowance.allowed_at_site)" href="analysis_config/config/#yousleep_common.models.analysis_config.config.SiteAllowance.allowed_at_site">allowed_at_site</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="by_exception pydantic-field (yousleep_common.models.analysis_config.config.SiteAllowance.by_exception)" href="analysis_config/config/#yousleep_common.models.analysis_config.config.SiteAllowance.by_exception">by_exception</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAllowance.allowed_at_site" class="doc doc-heading"> <code class="highlight language-python"><span class="n">allowed_at_site</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAllowance.allowed_at_site" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the organisation may run the analysis at its own site: its configuration allows a site, or an exception in force covers it for the organisation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAllowance.by_exception" class="doc doc-heading"> <code class="highlight language-python"><span class="n">by_exception</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAllowance.by_exception" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether only an exception in force allows it at the site: the configuration itself keeps the analysis on the platform.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAllowance.place" class="doc doc-heading"> <code class="highlight language-python"><span class="n">place</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAllowance.place" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where the organisation's analyses run now: on the platform, or at its own site.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteAllowance.runs_there" class="doc doc-heading"> <code class="highlight language-python"><span class="n">runs_there</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteAllowance.runs_there" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the analysis may run there. On the platform it always may; at the site, when <code>allowed_at_site</code> is true. Where it may not, the quote and the submission refuse it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteExceptionCreate" class="doc doc-heading"> <code>SiteExceptionCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteExceptionCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A platform administrator's record that an organisation may run a platform-only analysis at its site.</p> <p>It covers every version of the analysis until it expires or is revoked.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionCreate.analysis_config_id)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionCreate.analysis_config_id">analysis_config_id</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisConfigIdStr = Annotated[str, Field(min_length=4, max_length=64, pattern='^[a-z-]*\\d*$', examples=['u-sleep-research-v1'], description="The machine-readable identifier of the analysis configuration. Must be between 4 and 64 characters long. Must contain only lowercase letters, hyphens ('-'), and optionally end with digits (e.g., 'u-sleep-research-v1'). The id names one lineage of comparable results and never changes once registered.")] module-attribute (yousleep_common.fields.AnalysisConfigIdStr)" href="../fields/#yousleep_common.fields.AnalysisConfigIdStr">AnalysisConfigIdStr</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="agreement_reference pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionCreate.agreement_reference)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionCreate.agreement_reference">agreement_reference</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionCreate.expires_at)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionCreate.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionCreate.agreement_reference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">agreement_reference</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionCreate.agreement_reference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The agreement that protects the analysis's image at the site.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionCreate.analysis_config_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_config_id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionCreate.analysis_config_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The analysis, by its machine-readable id.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionCreate.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionCreate.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the exception ends; it must be in the future.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteExceptionOut" class="doc doc-heading"> <code>SiteExceptionOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One record of an exception: recorded, or revoked.</p> <p>Records only grow. The latest for an organisation and an analysis is its state: in force while it is recorded, not revoked, and unexpired.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.SiteExceptionOut.id">id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.SiteExceptionOut.org_id">org_id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.SiteExceptionOut.analysis_config_id">analysis_config_id</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="revoked pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionOut.revoked)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut.revoked">revoked</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="agreement_reference = None pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionOut.agreement_reference)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut.agreement_reference">agreement_reference</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="expires_at = None pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionOut.expires_at)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut.expires_at">expires_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="reason = None pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionOut.reason)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut.reason">reason</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recorded_by pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionOut.recorded_by)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut.recorded_by">recorded_by</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.SiteExceptionOut.recorded_at">recorded_at</span></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="in_force pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionOut.in_force)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut.in_force">in_force</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionOut.agreement_reference" class="doc doc-heading"> <code class="highlight language-python"><span class="n">agreement_reference</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut.agreement_reference" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The agreement it rests on; None on a revocation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionOut.expires_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">expires_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut.expires_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When it ends; None on a revocation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionOut.in_force" class="doc doc-heading"> <code class="highlight language-python"><span class="n">in_force</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut.in_force" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether this record is the latest for its analysis, is not a revocation, and has not expired.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionOut.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why it was revoked; None when recorded.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionOut.recorded_by" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recorded_by</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut.recorded_by" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The administrator who recorded it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionOut.revoked" class="doc doc-heading"> <code class="highlight language-python"><span class="n">revoked</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionOut.revoked" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether this record revokes the exception.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteExceptionPage" class="doc doc-heading"> <code>SiteExceptionPage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteExceptionPage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A page of an organisation's exception records, newest first.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.site_capabilities.SiteExceptionPage.exceptions">exceptions</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="SiteExceptionOut pydantic-model (yousleep_common.models.site_capabilities.SiteExceptionOut)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionOut">SiteExceptionOut</a>]</code>) </li> <li> <code><span title="yousleep_common.models.site_capabilities.SiteExceptionPage.total">total</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SiteExceptionRevoke" class="doc doc-heading"> <code>SiteExceptionRevoke</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SiteExceptionRevoke" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A platform administrator ending an exception before it expires.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="reason pydantic-field (yousleep_common.models.site_capabilities.SiteExceptionRevoke.reason)" href="site_capabilities/#yousleep_common.models.site_capabilities.SiteExceptionRevoke.reason">reason</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SiteExceptionRevoke.reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">reason</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SiteExceptionRevoke.reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why it ends, kept with the record.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SlotDefinition" class="doc doc-heading"> <code>SlotDefinition</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SlotDefinition" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An ordered, labelled input position of the analysis and the channel that fills it.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.analysis_manifest.SlotDefinition.label)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.SlotDefinition.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.analysis_manifest.SlotDefinition.laterality">laterality</span></code> (<code><a class="autorefs autorefs-internal" title="ChannelLaterality = Literal['left', 'right'] module-attribute (yousleep_common.types.channels.ChannelLaterality)" href="../types/channels/#yousleep_common.types.channels.ChannelLaterality">ChannelLaterality</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="channel_index pydantic-field (yousleep_common.models.analysis_manifest.SlotDefinition.channel_index)" href="analysis_manifest/#yousleep_common.models.analysis_manifest.SlotDefinition.channel_index">channel_index</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.analysis_manifest.SlotDefinition._drop_legacy_derivation">_drop_legacy_derivation</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SlotDefinition.channel_index" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channel_index</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SlotDefinition.channel_index" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The recording channel filling the slot.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SlotDefinition.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SlotDefinition.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The slot's label from the configuration.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StagePercentages" class="doc doc-heading"> <code>StagePercentages</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StagePercentages" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Stage percentages of total sleep time (N1–N3, REM) and time in bed (Wake).</p> <p>Each description is the metric's definition as the platform computes it, served as its help text; the sleep stages are empty (None) when no sleep is scored, since a share of zero sleep is undefined rather than 0%.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="n1_pct = None pydantic-field (yousleep_common.models.biomarkers.StagePercentages.n1_pct)" href="biomarkers/#yousleep_common.models.biomarkers.StagePercentages.n1_pct">n1_pct</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="n2_pct = None pydantic-field (yousleep_common.models.biomarkers.StagePercentages.n2_pct)" href="biomarkers/#yousleep_common.models.biomarkers.StagePercentages.n2_pct">n2_pct</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="n3_pct = None pydantic-field (yousleep_common.models.biomarkers.StagePercentages.n3_pct)" href="biomarkers/#yousleep_common.models.biomarkers.StagePercentages.n3_pct">n3_pct</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="rem_pct = None pydantic-field (yousleep_common.models.biomarkers.StagePercentages.rem_pct)" href="biomarkers/#yousleep_common.models.biomarkers.StagePercentages.rem_pct">rem_pct</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="wake_pct pydantic-field (yousleep_common.models.biomarkers.StagePercentages.wake_pct)" href="biomarkers/#yousleep_common.models.biomarkers.StagePercentages.wake_pct">wake_pct</a></code> (<code><span title="float">float</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StagePercentages.n1_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">n1_pct</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StagePercentages.n1_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>N1 time as a percentage of total sleep time (TST). Empty when no sleep is scored.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StagePercentages.n2_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">n2_pct</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StagePercentages.n2_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>N2 time as a percentage of total sleep time (TST). Empty when no sleep is scored.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StagePercentages.n3_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">n3_pct</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StagePercentages.n3_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>N3 time as a percentage of total sleep time (TST); Rechtschaffen & Kales stages 3 and 4 both count as N3. Empty when no sleep is scored.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StagePercentages.rem_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">rem_pct</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StagePercentages.rem_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>REM time as a percentage of total sleep time (TST). Empty when no sleep is scored.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StagePercentages.wake_pct" class="doc doc-heading"> <code class="highlight language-python"><span class="n">wake_pct</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StagePercentages.wake_pct" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Wake time as a percentage of time in bed (TIB), not of TST as for the sleep stages. Epochs scored as no stage (unscored, movement time) count toward TIB only, so wake and the sleep stages' share of TIB need not add up to 100%.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StatisticsWindow" class="doc doc-heading"> <code>StatisticsWindow</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StatisticsWindow" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The time window used for TIB-based statistics computation.</p> <p>Resolved from study events (lights off/on), client override, or full recording. The source field tells the frontend how the window was determined.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="start_time_ms pydantic-field (yousleep_common.models.reports.StatisticsWindow.start_time_ms)" href="reports/#yousleep_common.models.reports.StatisticsWindow.start_time_ms">start_time_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="end_time_ms pydantic-field (yousleep_common.models.reports.StatisticsWindow.end_time_ms)" href="reports/#yousleep_common.models.reports.StatisticsWindow.end_time_ms">end_time_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="source pydantic-field (yousleep_common.models.reports.StatisticsWindow.source)" href="reports/#yousleep_common.models.reports.StatisticsWindow.source">source</a></code> (<code><span title="yousleep_common.types.events.WindowSource">WindowSource</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StatisticsWindow.end_time_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">end_time_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StatisticsWindow.end_time_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Window end in ms from recording/study reference</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StatisticsWindow.source" class="doc doc-heading"> <code class="highlight language-python"><span class="n">source</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StatisticsWindow.source" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How this window was determined</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StatisticsWindow.start_time_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">start_time_ms</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StatisticsWindow.start_time_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Window start in ms from recording/study reference</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StepInputCoverage" class="doc doc-heading"> <code>StepInputCoverage</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StepInputCoverage" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What one step's recordings offer of the inputs its analysis declares.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.batch.StepInputCoverage.step_id">step_id</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recordings pydantic-field (yousleep_common.models.batch.StepInputCoverage.recordings)" href="batch/#yousleep_common.models.batch.StepInputCoverage.recordings">recordings</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="complete pydantic-field (yousleep_common.models.batch.StepInputCoverage.complete)" href="batch/#yousleep_common.models.batch.StepInputCoverage.complete">complete</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.batch.StepInputCoverage.inputs">inputs</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="InputCoverage pydantic-model (yousleep_common.models.batch.InputCoverage)" href="batch/#yousleep_common.models.batch.InputCoverage">InputCoverage</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StepInputCoverage.complete" class="doc doc-heading"> <code class="highlight language-python"><span class="n">complete</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StepInputCoverage.complete" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recordings with every declared input, optional ones included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StepInputCoverage.recordings" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recordings</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StepInputCoverage.recordings" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recordings the step was resolved against.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StorageBucketReconciliation" class="doc doc-heading"> <code>StorageBucketReconciliation</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One bucket's objects compared with the storage records that reference them.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="objects pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.objects)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.objects">objects</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tracked_live pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.tracked_live)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.tracked_live">tracked_live</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="missing pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.missing)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.missing">missing</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="missing_sample pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.missing_sample)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.missing_sample">missing_sample</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="untracked pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.untracked)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.untracked">untracked</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="untracked_sample pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.untracked_sample)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.untracked_sample">untracked_sample</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="awaiting_reap pydantic-field (yousleep_common.models.admin.StorageBucketReconciliation.awaiting_reap)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation.awaiting_reap">awaiting_reap</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.awaiting_reap" class="doc doc-heading"> <code class="highlight language-python"><span class="n">awaiting_reap</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.awaiting_reap" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Objects referenced only by deleted records, still waiting to be removed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.missing" class="doc doc-heading"> <code class="highlight language-python"><span class="n">missing</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.missing" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Live records whose object is gone. Anything above zero means stored data is lost and warrants immediate attention.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.missing_sample" class="doc doc-heading"> <code class="highlight language-python"><span class="n">missing_sample</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.missing_sample" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Some of the missing object keys, capped by the server.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.objects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">objects</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.objects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Objects in the bucket.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.tracked_live" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tracked_live</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.tracked_live" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Live records that reference an object in the bucket. Records with a scheduled expiry are not counted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.untracked" class="doc doc-heading"> <code class="highlight language-python"><span class="n">untracked</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.untracked" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Objects that no record references.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageBucketReconciliation.untracked_sample" class="doc doc-heading"> <code class="highlight language-python"><span class="n">untracked_sample</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageBucketReconciliation.untracked_sample" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Some of the untracked object keys, capped by the server.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StorageReconciliationNeverRun" class="doc doc-heading"> <code>StorageReconciliationNeverRun</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationNeverRun" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The answer when no reconciliation report is stored.</p> <p>Either none has run yet, or the last report has expired.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.admin.StorageReconciliationNeverRun.status">status</span></code> (<code><span title="typing.Literal">Literal</span>['never_run']</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StorageReconciliationReport" class="doc doc-heading"> <code>StorageReconciliationReport</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationReport" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The last storage reconciliation.</p> <p>Each data bucket's objects compared with the storage records, both ways. The report names drift and changes nothing; what to do about it is an operator's decision.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="timestamp pydantic-field (yousleep_common.models.admin.StorageReconciliationReport.timestamp)" href="admin/#yousleep_common.models.admin.StorageReconciliationReport.timestamp">timestamp</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="buckets pydantic-field (yousleep_common.models.admin.StorageReconciliationReport.buckets)" href="admin/#yousleep_common.models.admin.StorageReconciliationReport.buckets">buckets</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <a class="autorefs autorefs-internal" title="StorageBucketReconciliation pydantic-model (yousleep_common.models.admin.StorageBucketReconciliation)" href="admin/#yousleep_common.models.admin.StorageBucketReconciliation">StorageBucketReconciliation</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="missing_total pydantic-field (yousleep_common.models.admin.StorageReconciliationReport.missing_total)" href="admin/#yousleep_common.models.admin.StorageReconciliationReport.missing_total">missing_total</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="untracked_total pydantic-field (yousleep_common.models.admin.StorageReconciliationReport.untracked_total)" href="admin/#yousleep_common.models.admin.StorageReconciliationReport.untracked_total">untracked_total</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="duration_seconds pydantic-field (yousleep_common.models.admin.StorageReconciliationReport.duration_seconds)" href="admin/#yousleep_common.models.admin.StorageReconciliationReport.duration_seconds">duration_seconds</a></code> (<code><span title="float">float</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageReconciliationReport.buckets" class="doc doc-heading"> <code class="highlight language-python"><span class="n">buckets</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationReport.buckets" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The comparison for each bucket, by bucket name.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageReconciliationReport.duration_seconds" class="doc doc-heading"> <code class="highlight language-python"><span class="n">duration_seconds</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationReport.duration_seconds" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How long the reconciliation took.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageReconciliationReport.missing_total" class="doc doc-heading"> <code class="highlight language-python"><span class="n">missing_total</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationReport.missing_total" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Missing objects across all buckets.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageReconciliationReport.timestamp" class="doc doc-heading"> <code class="highlight language-python"><span class="n">timestamp</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationReport.timestamp" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the reconciliation ran.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StorageReconciliationReport.untracked_total" class="doc doc-heading"> <code class="highlight language-python"><span class="n">untracked_total</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StorageReconciliationReport.untracked_total" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Untracked objects across all buckets.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StratumCount" class="doc doc-heading"> <code>StratumCount</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StratumCount" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Cohort count for one stratum of a stratified report.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.reports.StratumCount.label)" href="reports/#yousleep_common.models.reports.StratumCount.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_count pydantic-field (yousleep_common.models.reports.StratumCount.study_count)" href="reports/#yousleep_common.models.reports.StratumCount.study_count">study_count</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StratumCount.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StratumCount.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The stratum's group label, exactly as it appears on the report's stats entries and chart rows.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StratumCount.study_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StratumCount.study_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many of the cohort fall in this stratum: distinct subjects when any study in scope carries a subject key, else studies — the same unit the report's demographics table counts.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StripeCheckoutSession" class="doc doc-heading"> <code>StripeCheckoutSession</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSession" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Represents minimal information on a stripe checkout session.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.stripe.StripeCheckoutSession.id)" href="stripe/#yousleep_common.models.stripe.StripeCheckoutSession.id">id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="fulfilled = False pydantic-field (yousleep_common.models.stripe.StripeCheckoutSession.fulfilled)" href="stripe/#yousleep_common.models.stripe.StripeCheckoutSession.fulfilled">fulfilled</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="url pydantic-field (yousleep_common.models.stripe.StripeCheckoutSession.url)" href="stripe/#yousleep_common.models.stripe.StripeCheckoutSession.url">url</a></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripeCheckoutSession.fulfilled" class="doc doc-heading"> <code class="highlight language-python"><span class="n">fulfilled</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSession.fulfilled" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the session has been fulfilled by the API server, i.e., if the user made the purchase whether the product/credits has been assigned to the user's account yet</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripeCheckoutSession.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSession.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique ID of the stripe checkout session.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripeCheckoutSession.url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">url</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSession.url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The URL the user is redirected to in order to complete the stripe session.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StripeCheckoutSessionCreate" class="doc doc-heading"> <code>StripeCheckoutSessionCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSessionCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request a Stripe checkout session for one or more credit packages.</p> <p>The redirect URLs are optional. When the server has a list of allowed application origins, each URL given must point to one of them.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="price_ids pydantic-field (yousleep_common.models.stripe.StripeCheckoutSessionCreate.price_ids)" href="stripe/#yousleep_common.models.stripe.StripeCheckoutSessionCreate.price_ids">price_ids</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="success_url = None pydantic-field (yousleep_common.models.stripe.StripeCheckoutSessionCreate.success_url)" href="stripe/#yousleep_common.models.stripe.StripeCheckoutSessionCreate.success_url">success_url</a></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="cancel_url = None pydantic-field (yousleep_common.models.stripe.StripeCheckoutSessionCreate.cancel_url)" href="stripe/#yousleep_common.models.stripe.StripeCheckoutSessionCreate.cancel_url">cancel_url</a></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripeCheckoutSessionCreate.cancel_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cancel_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSessionCreate.cancel_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where Stripe returns the buyer when they cancel.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripeCheckoutSessionCreate.price_ids" class="doc doc-heading"> <code class="highlight language-python"><span class="n">price_ids</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSessionCreate.price_ids" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stripe price ids to purchase, one per package: the <code>price_id</code> of each credit package.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripeCheckoutSessionCreate.success_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">success_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripeCheckoutSessionCreate.success_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where Stripe returns the buyer after payment. Required when the server has no configured application URL to fall back on.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StripePortalSession" class="doc doc-heading"> <code>StripePortalSession</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StripePortalSession" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A Stripe customer-portal session to redirect the browser to.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="url pydantic-field (yousleep_common.models.stripe.StripePortalSession.url)" href="stripe/#yousleep_common.models.stripe.StripePortalSession.url">url</a></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripePortalSession.url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">url</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripePortalSession.url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The Stripe-hosted portal URL. It is short-lived, so open it straight away.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StripePortalSessionCreate" class="doc doc-heading"> <code>StripePortalSessionCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StripePortalSessionCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request a Stripe customer-portal session: purchase history and invoices.</p> <p>Every field is optional; an empty body is a valid request.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="return_url = None pydantic-field (yousleep_common.models.stripe.StripePortalSessionCreate.return_url)" href="stripe/#yousleep_common.models.stripe.StripePortalSessionCreate.return_url">return_url</a></code> (<code><span title="pydantic.HttpUrl">HttpUrl</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StripePortalSessionCreate.return_url" class="doc doc-heading"> <code class="highlight language-python"><span class="n">return_url</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StripePortalSessionCreate.return_url" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Where Stripe sends the user when they leave the portal. When the server has a list of allowed application origins, it must point to one of them.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyCreate" class="doc doc-heading"> <code>StudyCreate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyCreate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="NamedEntityCreate pydantic-model (yousleep_common.models.base_models.NamedEntityCreate)" href="base_models/#yousleep_common.models.base_models.NamedEntityCreate">NamedEntityCreate</a></code>, <code><a class="autorefs autorefs-internal" title="StudyMetadata pydantic-model (yousleep_common.models.study.StudyMetadata)" href="study/#yousleep_common.models.study.StudyMetadata">StudyMetadata</a></code></p> <p>Create payload for a study. <code>name</code> is required.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="age = None pydantic-field (yousleep_common.models.study.StudyCreate.age)" href="#yousleep_common.models.StudyMetadata.age">age</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bmi = None pydantic-field (yousleep_common.models.study.StudyCreate.bmi)" href="#yousleep_common.models.StudyMetadata.bmi">bmi</a></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sex = None pydantic-field (yousleep_common.models.study.StudyCreate.sex)" href="#yousleep_common.models.StudyMetadata.sex">sex</a></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.Sex)" href="../types/#yousleep_common.types.Sex">Sex</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.study.StudyCreate.subject_key)" href="#yousleep_common.models.StudyMetadata.subject_key">subject_key</a></code> (<code><a class="autorefs autorefs-internal" title="SubjectKey = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)] module-attribute (yousleep_common.models.study.SubjectKey)" href="study/#yousleep_common.models.study.SubjectKey">SubjectKey</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="session_index = None pydantic-field (yousleep_common.models.study.StudyCreate.session_index)" href="#yousleep_common.models.StudyMetadata.session_index">session_index</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study.StudyCreate.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.study.StudyCreate.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.study.StudyCreate.name)" href="#yousleep_common.models.NamedEntityCreate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyEvent" class="doc doc-heading"> <code>StudyEvent</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyEvent" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A study-level event (e.g. lights off/on).</p> <p>Study events are definitionally certain — no probability or value fields. Times are milliseconds relative to the earliest recording start in the study.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.events.StudyEvent.id">id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEvent.study_id">study_id</span></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEvent.start_time_ms">start_time_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEvent.end_time_ms">end_time_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEvent.label">label</span></code> (<code><a class="autorefs autorefs-internal" title="EventLabel (yousleep_common.types.events.EventLabel)" href="../types/events/#yousleep_common.types.events.EventLabel">EventLabel</a></code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEvent.origin">origin</span></code> (<code><a class="autorefs autorefs-internal" title="StudyEventOrigin (yousleep_common.types.events.StudyEventOrigin)" href="../types/events/#yousleep_common.types.events.StudyEventOrigin">StudyEventOrigin</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_time_order() pydantic-validator (yousleep_common.models.events.StudyEvent.validate_time_order)" href="events/#yousleep_common.models.events.StudyEvent.validate_time_order">validate_time_order</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.StudyEvent.validate_time_order" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_time_order</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.StudyEvent.validate_time_order" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that start time is less than or equal to end time.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyEventInput" class="doc doc-heading"> <code>StudyEventInput</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyEventInput" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Input for creating or upserting a study event.</p> <p>Supports two input formats: - Relative: provide start_time_ms and end_time_ms directly. - Absolute: provide a datetime timestamp (converted to relative ms on ingestion; aware datetimes resolve as instants, naive datetimes are read in the recording's wall-clock frame — see <code>timestamp</code>).</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.events.StudyEventInput.start_time_ms">start_time_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEventInput.end_time_ms">end_time_ms</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="timestamp = None pydantic-field (yousleep_common.models.events.StudyEventInput.timestamp)" href="events/#yousleep_common.models.events.StudyEventInput.timestamp">timestamp</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.events.StudyEventInput.label">label</span></code> (<code><a class="autorefs autorefs-internal" title="EventLabel (yousleep_common.types.events.EventLabel)" href="../types/events/#yousleep_common.types.events.EventLabel">EventLabel</a></code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="validate_input_format() pydantic-validator (yousleep_common.models.events.StudyEventInput.validate_input_format)" href="events/#yousleep_common.models.events.StudyEventInput.validate_input_format">validate_input_format</a></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyEventInput.timestamp" class="doc doc-heading"> <code class="highlight language-python"><span class="n">timestamp</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyEventInput.timestamp" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Absolute event time, converted to relative ms against the study's earliest recording start. Timezone-aware datetimes are resolved as instants; naive datetimes are interpreted in the recording's own wall-clock frame (recording starts carry a nominal UTC offset).</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.StudyEventInput.validate_input_format" class="doc doc-heading"> <code class="highlight language-python"><span class="n">validate_input_format</span><span class="p">()</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-validator"><code>pydantic-validator</code></small> </span> <a href="#yousleep_common.models.StudyEventInput.validate_input_format" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Validate that exactly one input format is used.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyFilter" class="doc doc-heading"> <code>StudyFilter</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyFilter" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.selectors._FilterBase">_FilterBase</span></code></p> <p>Predicate over a project's studies; at least one field must be set.</p> <p>Mirrors the study list endpoint's filter query parameters.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="tags_any = None pydantic-field (yousleep_common.models.selectors.StudyFilter.tags_any)" href="selectors/#yousleep_common.models.selectors.StudyFilter.tags_any">tags_any</a></code> (<code><span title="list">list</span>[<span title="str">str</span>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name_contains = None pydantic-field (yousleep_common.models.selectors.StudyFilter.name_contains)" href="selectors/#yousleep_common.models.selectors.StudyFilter.name_contains">name_contains</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.selectors.StudyFilter.subject_key)" href="selectors/#yousleep_common.models.selectors.StudyFilter.subject_key">subject_key</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="missing_metadata_any = None pydantic-field (yousleep_common.models.selectors.StudyFilter.missing_metadata_any)" href="selectors/#yousleep_common.models.selectors.StudyFilter.missing_metadata_any">missing_metadata_any</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="MetadataType (yousleep_common.types.MetadataType)" href="../types/#yousleep_common.types.MetadataType">MetadataType</a>] | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.StudyFilter._at_least_one_predicate">_at_least_one_predicate</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyFilter.missing_metadata_any" class="doc doc-heading"> <code class="highlight language-python"><span class="n">missing_metadata_any</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyFilter.missing_metadata_any" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Match studies that do not record at least one of these subject values.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyFilter.name_contains" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name_contains</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyFilter.name_contains" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Match studies whose name contains this text (case-insensitive).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyFilter.subject_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyFilter.subject_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Match every study of one subject — the key is compared case- and whitespace-insensitively. Deleting by this filter is how a subject's data is erased: the studies are the subject.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyFilter.tags_any" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tags_any</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyFilter.tags_any" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Match studies carrying at least one of these tags.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyGroupSummary" class="doc doc-heading"> <code>StudyGroupSummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyGroupSummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A set of a project's studies: how many, and the first of them.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="count pydantic-field (yousleep_common.models.study.StudyGroupSummary.count)" href="study/#yousleep_common.models.study.StudyGroupSummary.count">count</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="studies pydantic-field (yousleep_common.models.study.StudyGroupSummary.studies)" href="study/#yousleep_common.models.study.StudyGroupSummary.studies">studies</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="StudyRef pydantic-model (yousleep_common.models.study.StudyRef)" href="study/#yousleep_common.models.study.StudyRef">StudyRef</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyGroupSummary.count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyGroupSummary.count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many studies the set holds.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyGroupSummary.studies" class="doc doc-heading"> <code class="highlight language-python"><span class="n">studies</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyGroupSummary.studies" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The first studies of the set in creation order, at most the summary's preview size.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyImportColumn" class="doc doc-heading"> <code>StudyImportColumn</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyImportColumn" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One column the import understands — drives auto-mapping and docs.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.study_import.StudyImportColumn.key)" href="study_import/#yousleep_common.models.study_import.StudyImportColumn.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="kind pydantic-field (yousleep_common.models.study_import.StudyImportColumn.kind)" href="study_import/#yousleep_common.models.study_import.StudyImportColumn.kind">kind</a></code> (<code><span title="yousleep_common.models.study_import.ColumnKind">ColumnKind</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="aliases pydantic-field (yousleep_common.models.study_import.StudyImportColumn.aliases)" href="study_import/#yousleep_common.models.study_import.StudyImportColumn.aliases">aliases</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.study_import.StudyImportColumn.unit)" href="study_import/#yousleep_common.models.study_import.StudyImportColumn.unit">unit</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="description pydantic-field (yousleep_common.models.study_import.StudyImportColumn.description)" href="study_import/#yousleep_common.models.study_import.StudyImportColumn.description">description</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyImportColumn.aliases" class="doc doc-heading"> <code class="highlight language-python"><span class="n">aliases</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyImportColumn.aliases" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Lower-cased header spellings that auto-map to this column.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyImportColumn.description" class="doc doc-heading"> <code class="highlight language-python"><span class="n">description</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyImportColumn.description" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the column sets.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyImportColumn.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyImportColumn.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Canonical column key (the API field name).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyImportColumn.kind" class="doc doc-heading"> <code class="highlight language-python"><span class="n">kind</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyImportColumn.kind" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Value shape, for parsing/validation.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyImportColumn.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyImportColumn.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display unit, if any.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyLightsAssignment" class="doc doc-heading"> <code>StudyLightsAssignment</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyLightsAssignment" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One study's lights markers.</p> <p>Presence semantics as everywhere in this module: an absent marker is left unchanged, an explicit null DELETES the marker. At least one of the two must be present.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.study_import.StudyLightsAssignment.study">study</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsAssignment.lights_off">lights_off</span></code> (<code><a class="autorefs autorefs-internal" title="LightsInstant pydantic-model (yousleep_common.models.study_import.LightsInstant)" href="study_import/#yousleep_common.models.study_import.LightsInstant">LightsInstant</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsAssignment.lights_on">lights_on</span></code> (<code><a class="autorefs autorefs-internal" title="LightsInstant pydantic-model (yousleep_common.models.study_import.LightsInstant)" href="study_import/#yousleep_common.models.study_import.LightsInstant">LightsInstant</a> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.study_import.StudyLightsAssignment._something_to_do">_something_to_do</span></code> </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyLightsResult" class="doc doc-heading"> <code>StudyLightsResult</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyLightsResult" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Outcome for one lights row.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.study_import.StudyLightsResult.study">study</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsResult.study_id">study_id</span></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsResult.status">status</span></code> (<code><span title="typing.Literal">Literal</span>['updated', 'error']</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsResult.lights_off_ms">lights_off_ms</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsResult.lights_on_ms">lights_on_ms</span></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyLightsResult.error">error</span></code> (<code><a class="autorefs autorefs-internal" title="BatchItemError pydantic-model (yousleep_common.models.batch.BatchItemError)" href="batch/#yousleep_common.models.batch.BatchItemError">BatchItemError</a> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyListResponse" class="doc doc-heading"> <code>StudyListResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyListResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="PaginatedResponse pydantic-model (yousleep_common.models.pagination.PaginatedResponse)" href="pagination/#yousleep_common.models.pagination.PaginatedResponse">PaginatedResponse</a></code></p> <p>A page of a project's studies.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.study.StudyListResponse.total)" href="#yousleep_common.models.PaginatedResponse.total">total</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="offset pydantic-field (yousleep_common.models.study.StudyListResponse.offset)" href="#yousleep_common.models.PaginatedResponse.offset">offset</a></code> (<code><span title="pydantic.types.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="limit pydantic-field (yousleep_common.models.study.StudyListResponse.limit)" href="#yousleep_common.models.PaginatedResponse.limit">limit</a></code> (<code><span title="pydantic.types.PositiveInt">PositiveInt</span></code>) </li> <li> <code><span title="yousleep_common.models.study.StudyListResponse.studies">studies</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="StudyOut pydantic-model (yousleep_common.models.study.StudyOut)" href="study/#yousleep_common.models.study.StudyOut">StudyOut</a>]</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyMetadata" class="doc doc-heading"> <code>StudyMetadata</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyMetadata" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A collection of optional metadata fields on a Study.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="age = None pydantic-field (yousleep_common.models.study.StudyMetadata.age)" href="study/#yousleep_common.models.study.StudyMetadata.age">age</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bmi = None pydantic-field (yousleep_common.models.study.StudyMetadata.bmi)" href="study/#yousleep_common.models.study.StudyMetadata.bmi">bmi</a></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sex = None pydantic-field (yousleep_common.models.study.StudyMetadata.sex)" href="study/#yousleep_common.models.study.StudyMetadata.sex">sex</a></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.Sex)" href="../types/#yousleep_common.types.Sex">Sex</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.study.StudyMetadata.subject_key)" href="study/#yousleep_common.models.study.StudyMetadata.subject_key">subject_key</a></code> (<code><a class="autorefs autorefs-internal" title="SubjectKey = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)] module-attribute (yousleep_common.models.study.SubjectKey)" href="study/#yousleep_common.models.study.SubjectKey">SubjectKey</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="session_index = None pydantic-field (yousleep_common.models.study.StudyMetadata.session_index)" href="study/#yousleep_common.models.study.StudyMetadata.session_index">session_index</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadata.age" class="doc doc-heading"> <code class="highlight language-python"><span class="n">age</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadata.age" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Age of the subject in years</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadata.bmi" class="doc doc-heading"> <code class="highlight language-python"><span class="n">bmi</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadata.bmi" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Body mass index of the subject</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadata.session_index" class="doc doc-heading"> <code class="highlight language-python"><span class="n">session_index</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadata.session_index" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Declared position of this study in its subject's series, 1 = first. Set only by the user; never allocated by the server. Null means the position is derived from the order of recording starts within the subject; a study whose recording start is unknown cannot be placed that way and needs a declared index.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadata.sex" class="doc doc-heading"> <code class="highlight language-python"><span class="n">sex</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadata.sex" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Biological sex of the subject</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadata.subject_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadata.subject_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The person this study belongs to. Studies in one project sharing a key form that subject's series; the key is compared case- and whitespace-insensitively and is unique to nothing — it groups, it does not identify. Null for a study that stands alone, which is every study until a key is set.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyMetadataPatch" class="doc doc-heading"> <code>StudyMetadataPatch</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyMetadataPatch" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One study's metadata changes.</p> <p>Field PRESENCE is the semantics: absent = unchanged, explicit null = clear. Serialize with <code>exclude_unset</code>. Bounds match the canonical <code>StudyMetadata</code> (the batch-creation item is harmonised to the same).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="study pydantic-field (yousleep_common.models.study_import.StudyMetadataPatch.study)" href="study_import/#yousleep_common.models.study_import.StudyMetadataPatch.study">study</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyMetadataPatch.age">age</span></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyMetadataPatch.sex">sex</span></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.Sex)" href="../types/#yousleep_common.types.Sex">Sex</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyMetadataPatch.bmi">bmi</span></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.study_import.StudyMetadataPatch.subject_key)" href="study_import/#yousleep_common.models.study_import.StudyMetadataPatch.subject_key">subject_key</a></code> (<code><a class="autorefs autorefs-internal" title="SubjectKey = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)] module-attribute (yousleep_common.models.study.SubjectKey)" href="study/#yousleep_common.models.study.SubjectKey">SubjectKey</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="session_index = None pydantic-field (yousleep_common.models.study_import.StudyMetadataPatch.session_index)" href="study_import/#yousleep_common.models.study_import.StudyMetadataPatch.session_index">session_index</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.study_import.StudyMetadataPatch._something_to_do">_something_to_do</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadataPatch.session_index" class="doc doc-heading"> <code class="highlight language-python"><span class="n">session_index</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadataPatch.session_index" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Declared position in the subject's series; null derives it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadataPatch.study" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadataPatch.study" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Study name or id. Names resolve within the project: 0 matches → not_found, >1 → conflict (rename or use ids).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadataPatch.subject_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadataPatch.subject_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The subject this study belongs to; null detaches it.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyMetadataResult" class="doc doc-heading"> <code>StudyMetadataResult</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyMetadataResult" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Outcome for one metadata patch row.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="study pydantic-field (yousleep_common.models.study_import.StudyMetadataResult.study)" href="study_import/#yousleep_common.models.study_import.StudyMetadataResult.study">study</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_id = None pydantic-field (yousleep_common.models.study_import.StudyMetadataResult.study_id)" href="study_import/#yousleep_common.models.study_import.StudyMetadataResult.study_id">study_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyMetadataResult.status">status</span></code> (<code><span title="typing.Literal">Literal</span>['updated', 'error']</code>) </li> <li> <code><span title="yousleep_common.models.study_import.StudyMetadataResult.error">error</span></code> (<code><a class="autorefs autorefs-internal" title="BatchItemError pydantic-model (yousleep_common.models.batch.BatchItemError)" href="batch/#yousleep_common.models.batch.BatchItemError">BatchItemError</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadataResult.study" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadataResult.study" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The row's study key, as submitted.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyMetadataResult.study_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyMetadataResult.study_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The resolved study, when resolution succeeded.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyOut" class="doc doc-heading"> <code>StudyOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="StudyCreate pydantic-model (yousleep_common.models.study.StudyCreate)" href="study/#yousleep_common.models.study.StudyCreate">StudyCreate</a></code></p> <p>Study information available to user.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="age = None pydantic-field (yousleep_common.models.study.StudyOut.age)" href="#yousleep_common.models.StudyMetadata.age">age</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bmi = None pydantic-field (yousleep_common.models.study.StudyOut.bmi)" href="#yousleep_common.models.StudyMetadata.bmi">bmi</a></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sex = None pydantic-field (yousleep_common.models.study.StudyOut.sex)" href="#yousleep_common.models.StudyMetadata.sex">sex</a></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.Sex)" href="../types/#yousleep_common.types.Sex">Sex</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.study.StudyOut.subject_key)" href="#yousleep_common.models.StudyMetadata.subject_key">subject_key</a></code> (<code><a class="autorefs autorefs-internal" title="SubjectKey = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)] module-attribute (yousleep_common.models.study.SubjectKey)" href="study/#yousleep_common.models.study.SubjectKey">SubjectKey</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="session_index = None pydantic-field (yousleep_common.models.study.StudyOut.session_index)" href="#yousleep_common.models.StudyMetadata.session_index">session_index</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study.StudyOut.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.study.StudyOut.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.study.StudyOut.name)" href="#yousleep_common.models.NamedEntityCreate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="owner_id = None pydantic-field (yousleep_common.models.study.StudyOut.owner_id)" href="study/#yousleep_common.models.study.StudyOut.owner_id">owner_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.study.StudyOut.id)" href="study/#yousleep_common.models.study.StudyOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_id = None pydantic-field (yousleep_common.models.study.StudyOut.project_id)" href="study/#yousleep_common.models.study.StudyOut.project_id">project_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.study.StudyOut.created_at)" href="study/#yousleep_common.models.study.StudyOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recording_count = 0 pydantic-field (yousleep_common.models.study.StudyOut.recording_count)" href="study/#yousleep_common.models.study.StudyOut.recording_count">recording_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyzed_count = 0 pydantic-field (yousleep_common.models.study.StudyOut.analyzed_count)" href="study/#yousleep_common.models.study.StudyOut.analyzed_count">analyzed_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses_count = 0 pydantic-field (yousleep_common.models.study.StudyOut.analyses_count)" href="study/#yousleep_common.models.study.StudyOut.analyses_count">analyses_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="total_duration_ms = 0 pydantic-field (yousleep_common.models.study.StudyOut.total_duration_ms)" href="study/#yousleep_common.models.study.StudyOut.total_duration_ms">total_duration_ms</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="first_recording_date = None pydantic-field (yousleep_common.models.study.StudyOut.first_recording_date)" href="study/#yousleep_common.models.study.StudyOut.first_recording_date">first_recording_date</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="has_lights = None pydantic-field (yousleep_common.models.study.StudyOut.has_lights)" href="study/#yousleep_common.models.study.StudyOut.has_lights">has_lights</a></code> (<code><span title="bool">bool</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lights_off_ms = None pydantic-field (yousleep_common.models.study.StudyOut.lights_off_ms)" href="study/#yousleep_common.models.study.StudyOut.lights_off_ms">lights_off_ms</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="lights_on_ms = None pydantic-field (yousleep_common.models.study.StudyOut.lights_on_ms)" href="study/#yousleep_common.models.study.StudyOut.lights_on_ms">lights_on_ms</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.analyses_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.analyses_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of analyses</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.analyzed_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyzed_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.analyzed_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Recordings with >= 1 completed analysis</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Creation timestamp of the study</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.first_recording_date" class="doc doc-heading"> <code class="highlight language-python"><span class="n">first_recording_date</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.first_recording_date" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Earliest recording start across the study's recordings — when the night was recorded, as opposed to when it was uploaded (created_at). None when no recording carries a start time.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.has_lights" class="doc doc-heading"> <code class="highlight language-python"><span class="n">has_lights</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.has_lights" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the study has lights off/on markers, i.e. its statistics will be lights-windowed. None when the producer did not compute it. Derivable from lights_off_ms/lights_on_ms where those are populated (kept for compatibility).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the study</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.lights_off_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lights_off_ms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.lights_off_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The lights-off marker, ms from the earliest recording start (first_recording_date is the clock frame). None = not set or not computed by the producer.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.lights_on_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">lights_on_ms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.lights_on_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The lights-on marker, ms from the earliest recording start. None = not set or not computed by the producer.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.owner_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">owner_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.owner_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The member who added it. Only they, or the project's owner, may change or remove it; it passes to the project's owner when they leave the organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.project_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.project_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The project the study belongs to.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.recording_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recording_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.recording_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Number of recordings</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyOut.total_duration_ms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total_duration_ms</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyOut.total_duration_ms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total recording duration in ms</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyRef" class="doc doc-heading"> <code>StudyRef</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyRef" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A study named in a summary: enough to show and link it.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.study.StudyRef.id)" href="study/#yousleep_common.models.study.StudyRef.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.study.StudyRef.name)" href="study/#yousleep_common.models.study.StudyRef.name">name</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyRef.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyRef.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The study's id.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyRef.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyRef.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The study's name.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyReportResponse" class="doc doc-heading"> <code>StudyReportResponse</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Envelope for study-level report data.</p> <p>Wraps event statistics with optional biomarkers and the statistics window used for TIB-based metric computation.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="event_stats pydantic-field (yousleep_common.models.reports.StudyReportResponse.event_stats)" href="reports/#yousleep_common.models.reports.StudyReportResponse.event_stats">event_stats</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="AnnotatedEventStats pydantic-model (yousleep_common.models.reports.AnnotatedEventStats)" href="reports/#yousleep_common.models.reports.AnnotatedEventStats">AnnotatedEventStats</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="statistics_window = None pydantic-field (yousleep_common.models.reports.StudyReportResponse.statistics_window)" href="reports/#yousleep_common.models.reports.StudyReportResponse.statistics_window">statistics_window</a></code> (<code><a class="autorefs autorefs-internal" title="StatisticsWindow pydantic-model (yousleep_common.models.reports.StatisticsWindow)" href="reports/#yousleep_common.models.reports.StatisticsWindow">StatisticsWindow</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="biomarkers = None pydantic-field (yousleep_common.models.reports.StudyReportResponse.biomarkers)" href="reports/#yousleep_common.models.reports.StudyReportResponse.biomarkers">biomarkers</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="BiomarkerResult pydantic-model (yousleep_common.models.biomarkers.BiomarkerResult)" href="biomarkers/#yousleep_common.models.biomarkers.BiomarkerResult">BiomarkerResult</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="warnings pydantic-field (yousleep_common.models.reports.StudyReportResponse.warnings)" href="reports/#yousleep_common.models.reports.StudyReportResponse.warnings">warnings</a></code> (<code><span title="list">list</span>[<span title="str">str</span>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="hypnograms = None pydantic-field (yousleep_common.models.reports.StudyReportResponse.hypnograms)" href="reports/#yousleep_common.models.reports.StudyReportResponse.hypnograms">hypnograms</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <a class="autorefs autorefs-internal" title="HypnogramModel pydantic-model (yousleep_common.models.charts.HypnogramModel)" href="charts/#yousleep_common.models.charts.HypnogramModel">HypnogramModel</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tables = None pydantic-field (yousleep_common.models.reports.StudyReportResponse.tables)" href="reports/#yousleep_common.models.reports.StudyReportResponse.tables">tables</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="TableModel pydantic-model (yousleep_common.models.tables.TableModel)" href="tables/#yousleep_common.models.tables.TableModel">TableModel</a>] | None</code>) </li> <li> <code><span title="yousleep_common.models.reports.StudyReportResponse.credits">credits</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="CreditedAnalysis pydantic-model (yousleep_common.models.reports.CreditedAnalysis)" href="reports/#yousleep_common.models.reports.CreditedAnalysis">CreditedAnalysis</a>]</code>) </li> <li> <code><span title="yousleep_common.models.reports.StudyReportResponse.sections">sections</span></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ReportSection pydantic-model (yousleep_common.models.reports.ReportSection)" href="reports/#yousleep_common.models.reports.ReportSection">ReportSection</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyReportResponse.biomarkers" class="doc doc-heading"> <code class="highlight language-python"><span class="n">biomarkers</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse.biomarkers" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-analysis biomarker results (None if not requested)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyReportResponse.event_stats" class="doc doc-heading"> <code class="highlight language-python"><span class="n">event_stats</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse.event_stats" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Per-analysis event statistics</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyReportResponse.hypnograms" class="doc doc-heading"> <code class="highlight language-python"><span class="n">hypnograms</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse.hypnograms" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-computed hypnogram chart models keyed by analysis_id. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyReportResponse.statistics_window" class="doc doc-heading"> <code class="highlight language-python"><span class="n">statistics_window</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse.statistics_window" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The time window used for statistics (None if no window available)</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyReportResponse.tables" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tables</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse.tables" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-defined tables: biomarker and event-metrics tables with formatting and semantic status computed once. None for producers predating the field.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudyReportResponse.warnings" class="doc doc-heading"> <code class="highlight language-python"><span class="n">warnings</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudyReportResponse.warnings" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Warnings about statistics computation</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudySelector" class="doc doc-heading"> <code>StudySelector</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudySelector" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="yousleep_common.models.selectors._SelectorBase">_SelectorBase</span></code></p> <p>Address a set of studies: exactly one of <code>ids</code> | <code>filter</code> | <code>all</code>.</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.StudySelector.ids">ids</span></code> (<code><span title="list">list</span>[<span title="uuid.UUID">UUID</span>] | None</code>) </li> <li> <code><span title="yousleep_common.models.selectors.StudySelector.all">all</span></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="filter = None pydantic-field (yousleep_common.models.selectors.StudySelector.filter)" href="selectors/#yousleep_common.models.selectors.StudySelector.filter">filter</a></code> (<code><a class="autorefs autorefs-internal" title="StudyFilter pydantic-model (yousleep_common.models.selectors.StudyFilter)" href="selectors/#yousleep_common.models.selectors.StudyFilter">StudyFilter</a> | None</code>) </li> </ul> <p>Validators:</p> <ul> <li> <code><span title="yousleep_common.models.selectors.StudySelector._exactly_one_mode">_exactly_one_mode</span></code> </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudySelector.filter" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">filter</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudySelector.filter" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Server-resolved predicate (live set).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudySummary" class="doc doc-heading"> <code>StudySummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudySummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What a project's studies hold, without listing them.</p> <p>Tag and subject vocabularies with their counts, and the first studies of each set, so a picker or a breakdown needs one small answer at any project size.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="total pydantic-field (yousleep_common.models.study.StudySummary.total)" href="study/#yousleep_common.models.study.StudySummary.total">total</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tags pydantic-field (yousleep_common.models.study.StudySummary.tags)" href="study/#yousleep_common.models.study.StudySummary.tags">tags</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="TagSummary pydantic-model (yousleep_common.models.study.TagSummary)" href="study/#yousleep_common.models.study.TagSummary">TagSummary</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="untagged pydantic-field (yousleep_common.models.study.StudySummary.untagged)" href="study/#yousleep_common.models.study.StudySummary.untagged">untagged</a></code> (<code><a class="autorefs autorefs-internal" title="StudyGroupSummary pydantic-model (yousleep_common.models.study.StudyGroupSummary)" href="study/#yousleep_common.models.study.StudyGroupSummary">StudyGroupSummary</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="excluded = None pydantic-field (yousleep_common.models.study.StudySummary.excluded)" href="study/#yousleep_common.models.study.StudySummary.excluded">excluded</a></code> (<code><a class="autorefs autorefs-internal" title="StudyGroupSummary pydantic-model (yousleep_common.models.study.StudyGroupSummary)" href="study/#yousleep_common.models.study.StudyGroupSummary">StudyGroupSummary</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subjects pydantic-field (yousleep_common.models.study.StudySummary.subjects)" href="study/#yousleep_common.models.study.StudySummary.subjects">subjects</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="SubjectSummary pydantic-model (yousleep_common.models.study.SubjectSummary)" href="study/#yousleep_common.models.study.SubjectSummary">SubjectSummary</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudySummary.excluded" class="doc doc-heading"> <code class="highlight language-python"><span class="n">excluded</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudySummary.excluded" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The studies carrying none of the requested <code>tags_any</code>; absent when none were requested.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudySummary.subjects" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subjects</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudySummary.subjects" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Every subject in the project, by normalised key.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudySummary.tags" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tags</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudySummary.tags" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Every tag in the project, the most studies first, then by tag.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudySummary.total" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudySummary.total" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many studies the project holds.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.StudySummary.untagged" class="doc doc-heading"> <code class="highlight language-python"><span class="n">untagged</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.StudySummary.untagged" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The studies carrying no tag.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.StudyUpdate" class="doc doc-heading"> <code>StudyUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.StudyUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="NamedEntityUpdate pydantic-model (yousleep_common.models.base_models.NamedEntityUpdate)" href="base_models/#yousleep_common.models.base_models.NamedEntityUpdate">NamedEntityUpdate</a></code>, <code><a class="autorefs autorefs-internal" title="StudyMetadata pydantic-model (yousleep_common.models.study.StudyMetadata)" href="study/#yousleep_common.models.study.StudyMetadata">StudyMetadata</a></code></p> <p>PATCH payload for a study — all fields are optional.</p> <p>See <code>NamedEntityUpdate</code> for the universal PATCH semantics (omit-to-skip, include-to-set, null-to-clear).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="age = None pydantic-field (yousleep_common.models.study.StudyUpdate.age)" href="#yousleep_common.models.StudyMetadata.age">age</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="bmi = None pydantic-field (yousleep_common.models.study.StudyUpdate.bmi)" href="#yousleep_common.models.StudyMetadata.bmi">bmi</a></code> (<code><span title="pydantic.PositiveFloat">PositiveFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="sex = None pydantic-field (yousleep_common.models.study.StudyUpdate.sex)" href="#yousleep_common.models.StudyMetadata.sex">sex</a></code> (<code><a class="autorefs autorefs-internal" title="Sex (yousleep_common.types.Sex)" href="../types/#yousleep_common.types.Sex">Sex</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subject_key = None pydantic-field (yousleep_common.models.study.StudyUpdate.subject_key)" href="#yousleep_common.models.StudyMetadata.subject_key">subject_key</a></code> (<code><a class="autorefs autorefs-internal" title="SubjectKey = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=64)] module-attribute (yousleep_common.models.study.SubjectKey)" href="study/#yousleep_common.models.study.SubjectKey">SubjectKey</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="session_index = None pydantic-field (yousleep_common.models.study.StudyUpdate.session_index)" href="#yousleep_common.models.StudyMetadata.session_index">session_index</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span> | None</code>) </li> <li> <code><span title="yousleep_common.models.study.StudyUpdate.tags">tags</span></code> (<code><a class="autorefs autorefs-internal" title="TagsSet = set[TagString] module-attribute (yousleep_common.fields.TagsSet)" href="../fields/#yousleep_common.fields.TagsSet">TagsSet</a> | None</code>) </li> <li> <code><span title="yousleep_common.models.study.StudyUpdate.description">description</span></code> (<code><a class="autorefs autorefs-internal" title="DescriptionStr = Annotated[str, Field(min_length=3, max_length=256, description='The user friendly description. Must be 3 to 256 characters long.')] module-attribute (yousleep_common.fields.DescriptionStr)" href="../fields/#yousleep_common.fields.DescriptionStr">DescriptionStr</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.study.StudyUpdate.name)" href="#yousleep_common.models.NamedEntityUpdate.name">name</a></code> (<code><a class="autorefs autorefs-internal" title="NameString = Annotated[str, StringConstraints(strip_whitespace=True, min_length=3, max_length=64, pattern="^[a-zA-Z0-9][a-zA-Z0-9 '_.\\-]*[a-zA-Z0-9'_.\\-]$")] module-attribute (yousleep_common.fields.NameString)" href="../fields/#yousleep_common.fields.NameString">NameString</a> | None</code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SubjectSummary" class="doc doc-heading"> <code>SubjectSummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SubjectSummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The studies of one subject.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="subject_key pydantic-field (yousleep_common.models.study.SubjectSummary.subject_key)" href="study/#yousleep_common.models.study.SubjectSummary.subject_key">subject_key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="count pydantic-field (yousleep_common.models.study.SubjectSummary.count)" href="study/#yousleep_common.models.study.SubjectSummary.count">count</a></code> (<code><span title="pydantic.PositiveInt">PositiveInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SubjectSummary.count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">count</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SubjectSummary.count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>How many studies the subject has.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SubjectSummary.subject_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subject_key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SubjectSummary.subject_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The subject key as first entered. Keys that differ only in case or whitespace are one subject.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.SummaryStats" class="doc doc-heading"> <code>SummaryStats</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.SummaryStats" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="BaseSummaryStats pydantic-model (yousleep_common.models.events.BaseSummaryStats)" href="events/#yousleep_common.models.events.BaseSummaryStats">BaseSummaryStats</a></code></p> <p>Summary statistics computed across a list of comparable events.</p> <p>Extends BaseSummaryStats with event-specific fields (analysis type, event type).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="analysis_config_id pydantic-field (yousleep_common.models.events.SummaryStats.analysis_config_id)" href="#yousleep_common.models.BaseSummaryStats.analysis_config_id">analysis_config_id</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_parameters pydantic-field (yousleep_common.models.events.SummaryStats.analysis_parameters)" href="#yousleep_common.models.BaseSummaryStats.analysis_parameters">analysis_parameters</a></code> (<code><span title="list">list</span>[<span title="tuple">tuple</span>[<span title="str">str</span>, <span title="str">str</span> | <span title="int">int</span> | <span title="float">float</span> | <span title="bool">bool</span>]]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="stats pydantic-field (yousleep_common.models.events.SummaryStats.stats)" href="#yousleep_common.models.BaseSummaryStats.stats">stats</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <a class="autorefs autorefs-internal" title="DistributionStats pydantic-model (yousleep_common.models.events.DistributionStats)" href="events/#yousleep_common.models.events.DistributionStats">DistributionStats</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="origins pydantic-field (yousleep_common.models.events.SummaryStats.origins)" href="#yousleep_common.models.BaseSummaryStats.origins">origins</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="StatsOrigin pydantic-model (yousleep_common.models.events.StatsOrigin)" href="events/#yousleep_common.models.events.StatsOrigin">StatsOrigin</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="origins_ref = None pydantic-field (yousleep_common.models.events.SummaryStats.origins_ref)" href="#yousleep_common.models.BaseSummaryStats.origins_ref">origins_ref</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="origins_summary = None pydantic-field (yousleep_common.models.events.SummaryStats.origins_summary)" href="#yousleep_common.models.BaseSummaryStats.origins_summary">origins_summary</a></code> (<code><a class="autorefs autorefs-internal" title="OriginsSummary pydantic-model (yousleep_common.models.events.OriginsSummary)" href="events/#yousleep_common.models.events.OriginsSummary">OriginsSummary</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analysis_type pydantic-field (yousleep_common.models.events.SummaryStats.analysis_type)" href="events/#yousleep_common.models.events.SummaryStats.analysis_type">analysis_type</a></code> (<code><a class="autorefs autorefs-internal" title="AnalysisType (yousleep_common.types.analyses.AnalysisType)" href="../types/analyses/#yousleep_common.types.analyses.AnalysisType">AnalysisType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="event_type pydantic-field (yousleep_common.models.events.SummaryStats.event_type)" href="events/#yousleep_common.models.events.SummaryStats.event_type">event_type</a></code> (<code><a class="autorefs autorefs-internal" title="EventType pydantic-model (yousleep_common.models.events.EventType)" href="events/#yousleep_common.models.events.EventType">EventType</a></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SummaryStats.analysis_type" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analysis_type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SummaryStats.analysis_type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type of analysis.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.SummaryStats.event_type" class="doc doc-heading"> <code class="highlight language-python"><span class="n">event_type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.SummaryStats.event_type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The type of event the summary statistics are computed over.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.TableCell" class="doc doc-heading"> <code>TableCell</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.TableCell" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One cell: raw value for machines, formatted text for humans.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="value = None pydantic-field (yousleep_common.models.tables.TableCell.value)" href="tables/#yousleep_common.models.tables.TableCell.value">value</a></code> (<code><span title="float">float</span> | <span title="int">int</span> | <span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="text pydantic-field (yousleep_common.models.tables.TableCell.text)" href="tables/#yousleep_common.models.tables.TableCell.text">text</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="detail = None pydantic-field (yousleep_common.models.tables.TableCell.detail)" href="tables/#yousleep_common.models.tables.TableCell.detail">detail</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="status = None pydantic-field (yousleep_common.models.tables.TableCell.status)" href="tables/#yousleep_common.models.tables.TableCell.status">status</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableCell.detail" class="doc doc-heading"> <code class="highlight language-python"><span class="n">detail</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableCell.detail" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The value at full precision with its unit, for hover text, where <code>text</code> rounds it (e.g. '1h 35m 12s' behind '1h 35m'). None where <code>text</code> is exact.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableCell.status" class="doc doc-heading"> <code class="highlight language-python"><span class="n">status</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableCell.status" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Semantic status token ('caution'/'danger'); None = neutral. Consumers resolve to brand colors; unknown tokens render neutral.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableCell.text" class="doc doc-heading"> <code class="highlight language-python"><span class="n">text</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableCell.text" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The display string, formatted server-side.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableCell.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableCell.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Raw value (tooltips, sorting, data-*).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.TableColumn" class="doc doc-heading"> <code>TableColumn</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.TableColumn" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One column: identity, labeling, and the curated-default flag.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.tables.TableColumn.key)" href="tables/#yousleep_common.models.tables.TableColumn.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.tables.TableColumn.label)" href="tables/#yousleep_common.models.tables.TableColumn.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit = None pydantic-field (yousleep_common.models.tables.TableColumn.unit)" href="tables/#yousleep_common.models.tables.TableColumn.unit">unit</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="align = 'right' pydantic-field (yousleep_common.models.tables.TableColumn.align)" href="tables/#yousleep_common.models.tables.TableColumn.align">align</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="description = None pydantic-field (yousleep_common.models.tables.TableColumn.description)" href="tables/#yousleep_common.models.tables.TableColumn.description">description</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="summary = True pydantic-field (yousleep_common.models.tables.TableColumn.summary)" href="tables/#yousleep_common.models.tables.TableColumn.summary">summary</a></code> (<code><span title="bool">bool</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableColumn.align" class="doc doc-heading"> <code class="highlight language-python"><span class="n">align</span> <span class="o">=</span> <span class="s1">'right'</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableColumn.align" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Cell alignment: 'left' for text, 'right' for numerals.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableColumn.description" class="doc doc-heading"> <code class="highlight language-python"><span class="n">description</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableColumn.description" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional plain-language definition of the column's metric, for hover/tooltip text.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableColumn.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableColumn.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable column identity (e.g. a metric key).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableColumn.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableColumn.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Header text.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableColumn.summary" class="doc doc-heading"> <code class="highlight language-python"><span class="n">summary</span> <span class="o">=</span> <span class="kc">True</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableColumn.summary" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether this column belongs to the curated default set — a HINT; every column always ships and the user's client-side selection always wins.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableColumn.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableColumn.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unit suffix (e.g. 'min', '%'); None = unitless.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.TableModel" class="doc doc-heading"> <code>TableModel</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.TableModel" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A fully server-defined table.</p> <p><code>key</code> uses the report section-key vocabulary (report_export module), so layout documents and exports address tables the same way pages do.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.tables.TableModel.key)" href="tables/#yousleep_common.models.tables.TableModel.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="title pydantic-field (yousleep_common.models.tables.TableModel.title)" href="tables/#yousleep_common.models.tables.TableModel.title">title</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="subtitle = '' pydantic-field (yousleep_common.models.tables.TableModel.subtitle)" href="tables/#yousleep_common.models.tables.TableModel.subtitle">subtitle</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="columns pydantic-field (yousleep_common.models.tables.TableModel.columns)" href="tables/#yousleep_common.models.tables.TableModel.columns">columns</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="TableColumn pydantic-model (yousleep_common.models.tables.TableColumn)" href="tables/#yousleep_common.models.tables.TableColumn">TableColumn</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="rows pydantic-field (yousleep_common.models.tables.TableModel.rows)" href="tables/#yousleep_common.models.tables.TableModel.rows">rows</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="TableRow pydantic-model (yousleep_common.models.tables.TableRow)" href="tables/#yousleep_common.models.tables.TableRow">TableRow</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="total_rows = None pydantic-field (yousleep_common.models.tables.TableModel.total_rows)" href="tables/#yousleep_common.models.tables.TableModel.total_rows">total_rows</a></code> (<code><span title="int">int</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableModel.columns" class="doc doc-heading"> <code class="highlight language-python"><span class="n">columns</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableModel.columns" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Column order is display order.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableModel.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableModel.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable table identity (section-key grammar).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableModel.rows" class="doc doc-heading"> <code class="highlight language-python"><span class="n">rows</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableModel.rows" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Row order is display order.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableModel.subtitle" class="doc doc-heading"> <code class="highlight language-python"><span class="n">subtitle</span> <span class="o">=</span> <span class="s1">''</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableModel.subtitle" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional subheading.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableModel.title" class="doc doc-heading"> <code class="highlight language-python"><span class="n">title</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableModel.title" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Human-readable table heading.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableModel.total_rows" class="doc doc-heading"> <code class="highlight language-python"><span class="n">total_rows</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableModel.total_rows" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total rows in the underlying data when <code>rows</code> is a server-capped excerpt; renderers should show 'rows of total_rows' and offer the full download the producing endpoint documents. None when <code>rows</code> is complete.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.TableRow" class="doc doc-heading"> <code>TableRow</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.TableRow" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One row: a label plus cells keyed by column key.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="key pydantic-field (yousleep_common.models.tables.TableRow.key)" href="tables/#yousleep_common.models.tables.TableRow.key">key</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="label pydantic-field (yousleep_common.models.tables.TableRow.label)" href="tables/#yousleep_common.models.tables.TableRow.label">label</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="description = None pydantic-field (yousleep_common.models.tables.TableRow.description)" href="tables/#yousleep_common.models.tables.TableRow.description">description</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="cells pydantic-field (yousleep_common.models.tables.TableRow.cells)" href="tables/#yousleep_common.models.tables.TableRow.cells">cells</a></code> (<code><span title="dict">dict</span>[<span title="str">str</span>, <a class="autorefs autorefs-internal" title="TableCell pydantic-model (yousleep_common.models.tables.TableCell)" href="tables/#yousleep_common.models.tables.TableCell">TableCell</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="summary = True pydantic-field (yousleep_common.models.tables.TableRow.summary)" href="tables/#yousleep_common.models.tables.TableRow.summary">summary</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="selection_key = None pydantic-field (yousleep_common.models.tables.TableRow.selection_key)" href="tables/#yousleep_common.models.tables.TableRow.selection_key">selection_key</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="selection_label = None pydantic-field (yousleep_common.models.tables.TableRow.selection_label)" href="tables/#yousleep_common.models.tables.TableRow.selection_label">selection_label</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.cells" class="doc doc-heading"> <code class="highlight language-python"><span class="n">cells</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.cells" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Cells keyed by TableColumn.key; a missing key renders as an em dash.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.description" class="doc doc-heading"> <code class="highlight language-python"><span class="n">description</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.description" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Optional plain-language definition of the row's metric, for hover/tooltip text (row-axis twin of TableColumn.description).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">key</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Stable row identity within the table.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">label</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Row header (e.g. an event type or metric).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.selection_key" class="doc doc-heading"> <code class="highlight language-python"><span class="n">selection_key</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.selection_key" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The key a row selection names, when it is not the row's own key: rows that repeat one metric per group or per event share it, so choosing the metric keeps it in every group.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.selection_label" class="doc doc-heading"> <code class="highlight language-python"><span class="n">selection_label</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.selection_label" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What a row picker calls <code>selection_key</code>: the metric's or event's name, listed once for every row that shares the key.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TableRow.summary" class="doc doc-heading"> <code class="highlight language-python"><span class="n">summary</span> <span class="o">=</span> <span class="kc">True</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TableRow.summary" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Row-axis twin of TableColumn.summary, for tables whose curated set is rows (e.g. biomarker headline metrics).</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.TagSummary" class="doc doc-heading"> <code>TagSummary</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.TagSummary" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="StudyGroupSummary pydantic-model (yousleep_common.models.study.StudyGroupSummary)" href="study/#yousleep_common.models.study.StudyGroupSummary">StudyGroupSummary</a></code></p> <p>The studies carrying one tag.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="count pydantic-field (yousleep_common.models.study.TagSummary.count)" href="#yousleep_common.models.StudyGroupSummary.count">count</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="studies pydantic-field (yousleep_common.models.study.TagSummary.studies)" href="#yousleep_common.models.StudyGroupSummary.studies">studies</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="StudyRef pydantic-model (yousleep_common.models.study.StudyRef)" href="study/#yousleep_common.models.study.StudyRef">StudyRef</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="tag pydantic-field (yousleep_common.models.study.TagSummary.tag)" href="study/#yousleep_common.models.study.TagSummary.tag">tag</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TagSummary.tag" class="doc doc-heading"> <code class="highlight language-python"><span class="n">tag</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TagSummary.tag" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The tag.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.TokenPair" class="doc doc-heading"> <code>TokenPair</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.TokenPair" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="AccessToken pydantic-model (yousleep_common.models.authentication.AccessToken)" href="authentication/#yousleep_common.models.authentication.AccessToken">AccessToken</a></code></p> <p>Full token pair returned by login: access token plus refresh token.</p> <p>(<code>user_id</code> and the access-token fields are inherited from <code>AccessToken</code>.)</p> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.authentication.TokenPair.access_token">access_token</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.authentication.TokenPair.access_token_expires_utc_seconds">access_token_expires_utc_seconds</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><span title="yousleep_common.models.authentication.TokenPair.user_id">user_id</span></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><span title="yousleep_common.models.authentication.TokenPair.refresh_token">refresh_token</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.authentication.TokenPair.refresh_token_expires_utc_seconds">refresh_token_expires_utc_seconds</span></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="consent_required = False pydantic-field (yousleep_common.models.authentication.TokenPair.consent_required)" href="authentication/#yousleep_common.models.authentication.TokenPair.consent_required">consent_required</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="pending_consents pydantic-field (yousleep_common.models.authentication.TokenPair.pending_consents)" href="authentication/#yousleep_common.models.authentication.TokenPair.pending_consents">pending_consents</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="PendingConsent pydantic-model (yousleep_common.models.consent.PendingConsent)" href="consent/#yousleep_common.models.consent.PendingConsent">PendingConsent</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TokenPair.consent_required" class="doc doc-heading"> <code class="highlight language-python"><span class="n">consent_required</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TokenPair.consent_required" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>True if the user must accept one or more legal documents before protected endpoints will authorize.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.TokenPair.pending_consents" class="doc doc-heading"> <code class="highlight language-python"><span class="n">pending_consents</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.TokenPair.pending_consents" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Documents (and versions) the user must still accept. Empty unless consent_required.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UniqueChannel" class="doc doc-heading"> <code>UniqueChannel</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UniqueChannel" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>A unique channel with its locations across recordings.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="channel_name pydantic-field (yousleep_common.models.reports.UniqueChannel.channel_name)" href="reports/#yousleep_common.models.reports.UniqueChannel.channel_name">channel_name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="type pydantic-field (yousleep_common.models.reports.UniqueChannel.type)" href="reports/#yousleep_common.models.reports.UniqueChannel.type">type</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelType (yousleep_common.types.ChannelType)" href="../types/#yousleep_common.types.ChannelType">ChannelType</a> | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="unit pydantic-field (yousleep_common.models.reports.UniqueChannel.unit)" href="reports/#yousleep_common.models.reports.UniqueChannel.unit">unit</a></code> (<code><a class="autorefs autorefs-internal" title="PhysicalDimension (yousleep_common.types.PhysicalDimension)" href="../types/#yousleep_common.types.PhysicalDimension">PhysicalDimension</a> | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="records pydantic-field (yousleep_common.models.reports.UniqueChannel.records)" href="reports/#yousleep_common.models.reports.UniqueChannel.records">records</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ChannelLocation pydantic-model (yousleep_common.models.reports.ChannelLocation)" href="reports/#yousleep_common.models.reports.ChannelLocation">ChannelLocation</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="identity = None pydantic-field (yousleep_common.models.reports.UniqueChannel.identity)" href="reports/#yousleep_common.models.reports.UniqueChannel.identity">identity</a></code> (<code><a class="autorefs autorefs-internal" title="ChannelIdentitySummary pydantic-model (yousleep_common.models.reports.ChannelIdentitySummary)" href="reports/#yousleep_common.models.reports.ChannelIdentitySummary">ChannelIdentitySummary</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UniqueChannel.channel_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">channel_name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UniqueChannel.channel_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Name of the channel</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UniqueChannel.identity" class="doc doc-heading"> <code class="highlight language-python"><span class="n">identity</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UniqueChannel.identity" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What these channels are, as stored on their rows (canonical name, side, and whether a person corrected any). None from a server that predates channel identity.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UniqueChannel.records" class="doc doc-heading"> <code class="highlight language-python"><span class="n">records</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UniqueChannel.records" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Locations where this channel appears</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UniqueChannel.type" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UniqueChannel.type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Type of the channel</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UniqueChannel.unit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">unit</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UniqueChannel.unit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Physical unit of the channel</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UploadedFile" class="doc doc-heading"> <code>UploadedFile</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UploadedFile" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>An output the runner uploaded to its presigned URL.</p> <p>Config:</p> <ul> <li><code>extra</code>: <code class="highlight language-python"><span class="n">forbid</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><span title="yousleep_common.models.runner.UploadedFile.container_path">container_path</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.UploadedFile.sha256">sha256</span></code> (<code><span title="str">str</span></code>) </li> <li> <code><span title="yousleep_common.models.runner.UploadedFile.size">size</span></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UsageBase" class="doc doc-heading"> <code>UsageBase</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UsageBase" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Base model for the UsageCount, UsageHours, and UsageBytes models.</p> <p>The all_time field represents the total number of items counted over the lifetime of the account. The active field represents the total number of items actively in use by the user.</p> <p>The fields can be non-negative integers or floats. The special case of None is also allowed to represent an unlimited resource when the UsageBase class is used to represent a set of limits on a resource instead of usage statistics. The increment and decrement methods cannot be used when the fields are None.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="all_time pydantic-field (yousleep_common.models.usage.UsageBase.all_time)" href="usage/#yousleep_common.models.usage.UsageBase.all_time">all_time</a></code> (<code><span title="pydantic.NonNegativeFloat">NonNegativeFloat</span> | <span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="active pydantic-field (yousleep_common.models.usage.UsageBase.active)" href="usage/#yousleep_common.models.usage.UsageBase.active">active</a></code> (<code><span title="pydantic.NonNegativeFloat">NonNegativeFloat</span> | <span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageBase.active" class="doc doc-heading"> <code class="highlight language-python"><span class="n">active</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageBase.active" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of items actively in use by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageBase.all_time" class="doc doc-heading"> <code class="highlight language-python"><span class="n">all_time</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageBase.all_time" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of items counted over the lifetime of the account.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.UsageBase.is_within_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">is_within_limit</span><span class="p">(</span><span class="n">limit</span><span class="p">)</span></code> <a href="#yousleep_common.models.UsageBase.is_within_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Check if the usage represented by this model is within a set of usage limits.</p> <p>Check if the usage represented by this model is within a set of usage limits represented by the 'limit' model. The usage is satisfied if the all_time and active values in this model are less than or equal to the corresponding values in the 'limit' model or if the corresponding value in the limit model is None.</p> <p><span class="doc-section-title">Examples:</span></p> <ul> <li>if the all_time value in this model is 10 and the all_time value in the 'limit' model is 20, then this method will return True.</li> <li>If the active value in this model is 10 and the active value in the 'limit' model is None, then this method will return True.</li> <li>If the active value in this model is 10 and the active value in the 'limit' model is 5, then this method will return False.</li> </ul> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UsageBytes" class="doc doc-heading"> <code>UsageBytes</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UsageBytes" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="UsageBase pydantic-model (yousleep_common.models.usage.UsageBase)" href="usage/#yousleep_common.models.usage.UsageBase">UsageBase</a></code></p> <p>Represents the amount of storage in bytes used by a user.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="all_time = 0 pydantic-field (yousleep_common.models.usage.UsageBytes.all_time)" href="usage/#yousleep_common.models.usage.UsageBytes.all_time">all_time</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="active = 0 pydantic-field (yousleep_common.models.usage.UsageBytes.active)" href="usage/#yousleep_common.models.usage.UsageBytes.active">active</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageBytes.active" class="doc doc-heading"> <code class="highlight language-python"><span class="n">active</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageBytes.active" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of bytes of storage actively in use by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageBytes.all_time" class="doc doc-heading"> <code class="highlight language-python"><span class="n">all_time</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageBytes.all_time" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of bytes of storage used by the user over the lifetime of the account.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UsageCount" class="doc doc-heading"> <code>UsageCount</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UsageCount" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="UsageBase pydantic-model (yousleep_common.models.usage.UsageBase)" href="usage/#yousleep_common.models.usage.UsageBase">UsageBase</a></code></p> <p>Represents a usage counter witch a all time and active value.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="all_time = 0 pydantic-field (yousleep_common.models.usage.UsageCount.all_time)" href="usage/#yousleep_common.models.usage.UsageCount.all_time">all_time</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="active = 0 pydantic-field (yousleep_common.models.usage.UsageCount.active)" href="usage/#yousleep_common.models.usage.UsageCount.active">active</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageCount.active" class="doc doc-heading"> <code class="highlight language-python"><span class="n">active</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageCount.active" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of items actively in use by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageCount.all_time" class="doc doc-heading"> <code class="highlight language-python"><span class="n">all_time</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageCount.all_time" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of items counted over the lifetime of the account.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UsageHours" class="doc doc-heading"> <code>UsageHours</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UsageHours" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="UsageBase pydantic-model (yousleep_common.models.usage.UsageBase)" href="usage/#yousleep_common.models.usage.UsageBase">UsageBase</a></code></p> <p>Represents the number of hours of signal data processed by an analysis for a given user.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="all_time = 0.0 pydantic-field (yousleep_common.models.usage.UsageHours.all_time)" href="usage/#yousleep_common.models.usage.UsageHours.all_time">all_time</a></code> (<code><span title="pydantic.NonNegativeFloat">NonNegativeFloat</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="active = 0.0 pydantic-field (yousleep_common.models.usage.UsageHours.active)" href="usage/#yousleep_common.models.usage.UsageHours.active">active</a></code> (<code><span title="pydantic.NonNegativeFloat">NonNegativeFloat</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageHours.active" class="doc doc-heading"> <code class="highlight language-python"><span class="n">active</span> <span class="o">=</span> <span class="mf">0.0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageHours.active" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of hours of recordings analysed by the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UsageHours.all_time" class="doc doc-heading"> <code class="highlight language-python"><span class="n">all_time</span> <span class="o">=</span> <span class="mf">0.0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UsageHours.all_time" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Total number of hours of recoridngs analysed over the lifetime of the account.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserAuthentication" class="doc doc-heading"> <code>UserAuthentication</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserAuthentication" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Model for the login auth.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.authentication.UserAuthentication.email)" href="authentication/#yousleep_common.models.authentication.UserAuthentication.email">email</a></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="password pydantic-field (yousleep_common.models.authentication.UserAuthentication.password)" href="authentication/#yousleep_common.models.authentication.UserAuthentication.password">password</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserAuthentication.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserAuthentication.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The email of the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserAuthentication.password" class="doc doc-heading"> <code class="highlight language-python"><span class="n">password</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserAuthentication.password" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The password of the user.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserFriendlyNamedValue" class="doc doc-heading"> <code>UserFriendlyNamedValue</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserFriendlyNamedValue" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Value with a user friendly name.</p> <p>This is used to represent a value that can be presented to the user in a user-friendly way with a description of the value.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="value pydantic-field (yousleep_common.models.analysis_config.primitives.UserFriendlyNamedValue.value)" href="analysis_config/primitives/#yousleep_common.models.analysis_config.primitives.UserFriendlyNamedValue.value">value</a></code> (<code><span title="str">str</span> | <span title="int">int</span> | <span title="float">float</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="description pydantic-field (yousleep_common.models.analysis_config.primitives.UserFriendlyNamedValue.description)" href="analysis_config/primitives/#yousleep_common.models.analysis_config.primitives.UserFriendlyNamedValue.description">description</a></code> (<code><span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserFriendlyNamedValue.description" class="doc doc-heading"> <code class="highlight language-python"><span class="n">description</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserFriendlyNamedValue.description" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Representation of the value of the choice to be presented to the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserFriendlyNamedValue.value" class="doc doc-heading"> <code class="highlight language-python"><span class="n">value</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserFriendlyNamedValue.value" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The value of the choice.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.UserFriendlyNamedValue.__eq__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__eq__</span><span class="p">(</span><span class="n">other</span><span class="p">)</span></code> <a href="#yousleep_common.models.UserFriendlyNamedValue.__eq__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Check equality with another UserFriendlyNamedValue or a value.</p> </div> </div> <div class="doc doc-object doc-function"> <h3 id="yousleep_common.models.UserFriendlyNamedValue.__hash__" class="doc doc-heading"> <code class="highlight language-python"><span class="fm">__hash__</span><span class="p">()</span></code> <a href="#yousleep_common.models.UserFriendlyNamedValue.__hash__" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Return a hash of the value.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserInformation" class="doc doc-heading"> <code>UserInformation</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserInformation" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Profile/vetting fields for a user.</p> <p>All optional at this level so response models (<code>UserOut</code>/<code>AdminUserOut</code>) can be built from existing accounts that predate these fields. <code>UserRegistration</code> overrides the request-access fields as required.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.authentication.UserInformation.name)" href="authentication/#yousleep_common.models.authentication.UserInformation.name">name</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="organization = None pydantic-field (yousleep_common.models.authentication.UserInformation.organization)" href="authentication/#yousleep_common.models.authentication.UserInformation.organization">organization</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="position = None pydantic-field (yousleep_common.models.authentication.UserInformation.position)" href="authentication/#yousleep_common.models.authentication.UserInformation.position">position</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="usage_type = None pydantic-field (yousleep_common.models.authentication.UserInformation.usage_type)" href="authentication/#yousleep_common.models.authentication.UserInformation.usage_type">usage_type</a></code> (<code><a class="autorefs autorefs-internal" title="UsageType (yousleep_common.types.UsageType)" href="../types/#yousleep_common.types.UsageType">UsageType</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="purpose = None pydantic-field (yousleep_common.models.authentication.UserInformation.purpose)" href="authentication/#yousleep_common.models.authentication.UserInformation.purpose">purpose</a></code> (<code>None | <span title="str">str</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserInformation.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserInformation.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's name, as they wish to be addressed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserInformation.organization" class="doc doc-heading"> <code class="highlight language-python"><span class="n">organization</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserInformation.organization" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization, lab, or company the user is affiliated with (or 'Independent').</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserInformation.position" class="doc doc-heading"> <code class="highlight language-python"><span class="n">position</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserInformation.position" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's position/role in their organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserInformation.purpose" class="doc doc-heading"> <code class="highlight language-python"><span class="n">purpose</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserInformation.purpose" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the user plans to use the platform for — the basis for request-access review.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserInformation.usage_type" class="doc doc-heading"> <code class="highlight language-python"><span class="n">usage_type</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserInformation.usage_type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's primary intended use of the platform.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserOrganizationOut" class="doc doc-heading"> <code>UserOrganizationOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>The caller's organization, as the caller sees it.</p> <p>A member-level view: identity, the caller's own role and membership, and the seat picture. Admin-only organization details (overrides, insolvency state) stay on :class:<code>Organization</code> behind the admin endpoints.</p> <p>Every account belongs to exactly one organization: the one created for it at sign-up, or the one it joined by invitation. Projects, credits and storage all belong to it.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.organization.UserOrganizationOut.id)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.id">id</a></code> (<code><span title="uuid.UUID">UUID</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.organization.UserOrganizationOut.name)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role pydantic-field (yousleep_common.models.organization.UserOrganizationOut.role)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.organization.MembershipRole)" href="../types/organization/#yousleep_common.types.organization.MembershipRole">MembershipRole</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="membership_id = None pydantic-field (yousleep_common.models.organization.UserOrganizationOut.membership_id)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.membership_id">membership_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="member_count = 1 pydantic-field (yousleep_common.models.organization.UserOrganizationOut.member_count)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.member_count">member_count</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="seat_limit = None pydantic-field (yousleep_common.models.organization.UserOrganizationOut.seat_limit)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.seat_limit">seat_limit</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="study_limit = None pydantic-field (yousleep_common.models.organization.UserOrganizationOut.study_limit)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.study_limit">study_limit</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_limit = None pydantic-field (yousleep_common.models.organization.UserOrganizationOut.project_limit)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.project_limit">project_limit</a></code> (<code><span title="int">int</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="storage_ceiling_gb = None pydantic-field (yousleep_common.models.organization.UserOrganizationOut.storage_ceiling_gb)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.storage_ceiling_gb">storage_ceiling_gb</a></code> (<code><span title="float">float</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="analyses_at_site = False pydantic-field (yousleep_common.models.organization.UserOrganizationOut.analyses_at_site)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.analyses_at_site">analyses_at_site</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="recordings_at_site = False pydantic-field (yousleep_common.models.organization.UserOrganizationOut.recordings_at_site)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.recordings_at_site">recordings_at_site</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="created_at pydantic-field (yousleep_common.models.organization.UserOrganizationOut.created_at)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.created_at">created_at</a></code> (<code><span title="datetime.datetime">datetime</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="project_count = 0 pydantic-field (yousleep_common.models.organization.UserOrganizationOut.project_count)" href="organization/#yousleep_common.models.organization.UserOrganizationOut.project_count">project_count</a></code> (<code><span title="int">int</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.analyses_at_site" class="doc doc-heading"> <code class="highlight language-python"><span class="n">analyses_at_site</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.analyses_at_site" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the organization's analyses run at its site, on its own runners, instead of on the platform.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.created_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">created_at</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.created_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>When the organization was created</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the organization</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.member_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">member_count</span> <span class="o">=</span> <span class="mi">1</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.member_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Members of the organization, the caller included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.membership_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">membership_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.membership_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The caller's membership in this organization; the id to address when leaving it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Display name of the organization</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.project_count" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_count</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.project_count" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Projects in the organization. On accepting an invitation elsewhere they come along, private.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.project_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">project_limit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.project_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Projects the organization may hold; null when unlimited.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.recordings_at_site" class="doc doc-heading"> <code class="highlight language-python"><span class="n">recordings_at_site</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.recordings_at_site" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the organization's new projects keep their recordings in its own bucket.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The caller's role in this organization.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.seat_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">seat_limit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.seat_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Members plus pending invitations the organization may hold; null when unlimited.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.storage_ceiling_gb" class="doc doc-heading"> <code class="highlight language-python"><span class="n">storage_ceiling_gb</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.storage_ceiling_gb" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The storage the organization may use, in GB. The ceiling in force, not an override.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOrganizationOut.study_limit" class="doc doc-heading"> <code class="highlight language-python"><span class="n">study_limit</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOrganizationOut.study_limit" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Studies one of the organization's projects may hold.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserOut" class="doc doc-heading"> <code>UserOut</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserOut" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="UserInformation pydantic-model (yousleep_common.models.authentication.UserInformation)" href="authentication/#yousleep_common.models.authentication.UserInformation">UserInformation</a></code></p> <p>User output/response model.</p> <p>Extends :class:<code>UserInformation</code> so users can see their own profile (name/organization/position/usage_type/purpose — e.g. the account page shows which licence their usage type requires). All profile fields stay optional (accounts may predate them).</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.authentication.UserOut.name)" href="#yousleep_common.models.UserInformation.name">name</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="organization = None pydantic-field (yousleep_common.models.authentication.UserOut.organization)" href="#yousleep_common.models.UserInformation.organization">organization</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="position = None pydantic-field (yousleep_common.models.authentication.UserOut.position)" href="#yousleep_common.models.UserInformation.position">position</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="usage_type = None pydantic-field (yousleep_common.models.authentication.UserOut.usage_type)" href="#yousleep_common.models.UserInformation.usage_type">usage_type</a></code> (<code><a class="autorefs autorefs-internal" title="UsageType (yousleep_common.types.UsageType)" href="../types/#yousleep_common.types.UsageType">UsageType</a> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="purpose = None pydantic-field (yousleep_common.models.authentication.UserOut.purpose)" href="#yousleep_common.models.UserInformation.purpose">purpose</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="id pydantic-field (yousleep_common.models.authentication.UserOut.id)" href="authentication/#yousleep_common.models.authentication.UserOut.id">id</a></code> (<code><span title="pydantic.UUID7">UUID7</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="permissions = [] pydantic-field (yousleep_common.models.authentication.UserOut.permissions)" href="authentication/#yousleep_common.models.authentication.UserOut.permissions">permissions</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="Permission (yousleep_common.types.Permission)" href="../types/#yousleep_common.types.Permission">Permission</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="role = Role.USER pydantic-field (yousleep_common.models.authentication.UserOut.role)" href="authentication/#yousleep_common.models.authentication.UserOut.role">role</a></code> (<code><a class="autorefs autorefs-internal" title="Role (yousleep_common.types.Role)" href="../types/#yousleep_common.types.Role">Role</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.authentication.UserOut.email)" href="authentication/#yousleep_common.models.authentication.UserOut.email">email</a></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email_confirmed_at = None pydantic-field (yousleep_common.models.authentication.UserOut.email_confirmed_at)" href="authentication/#yousleep_common.models.authentication.UserOut.email_confirmed_at">email_confirmed_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="approved_at = None pydantic-field (yousleep_common.models.authentication.UserOut.approved_at)" href="authentication/#yousleep_common.models.authentication.UserOut.approved_at">approved_at</a></code> (<code><span title="datetime.datetime">datetime</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="consent_required = False pydantic-field (yousleep_common.models.authentication.UserOut.consent_required)" href="authentication/#yousleep_common.models.authentication.UserOut.consent_required">consent_required</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="pending_consents pydantic-field (yousleep_common.models.authentication.UserOut.pending_consents)" href="authentication/#yousleep_common.models.authentication.UserOut.pending_consents">pending_consents</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="PendingConsent pydantic-model (yousleep_common.models.consent.PendingConsent)" href="consent/#yousleep_common.models.consent.PendingConsent">PendingConsent</a>]</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="has_billing_account = False pydantic-field (yousleep_common.models.authentication.UserOut.has_billing_account)" href="authentication/#yousleep_common.models.authentication.UserOut.has_billing_account">has_billing_account</a></code> (<code><span title="bool">bool</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="organization_id = None pydantic-field (yousleep_common.models.authentication.UserOut.organization_id)" href="authentication/#yousleep_common.models.authentication.UserOut.organization_id">organization_id</a></code> (<code><span title="uuid.UUID">UUID</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="organization_name = None pydantic-field (yousleep_common.models.authentication.UserOut.organization_name)" href="authentication/#yousleep_common.models.authentication.UserOut.organization_name">organization_name</a></code> (<code><span title="str">str</span> | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="organization_role = None pydantic-field (yousleep_common.models.authentication.UserOut.organization_role)" href="authentication/#yousleep_common.models.authentication.UserOut.organization_role">organization_role</a></code> (<code><a class="autorefs autorefs-internal" title="MembershipRole (yousleep_common.types.organization.MembershipRole)" href="../types/organization/#yousleep_common.types.organization.MembershipRole">MembershipRole</a> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.approved_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">approved_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.approved_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Timestamp when an admin approved the account (request-access flow). Null means the registration is still pending approval and login is blocked; distinct from <code>disabled</code>, which bans an already-approved account.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.consent_required" class="doc doc-heading"> <code class="highlight language-python"><span class="n">consent_required</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.consent_required" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>True if the user must accept one or more legal documents before protected endpoints will authorize.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Email address of the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.email_confirmed_at" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email_confirmed_at</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.email_confirmed_at" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Timestamp when the user's email was confirmed.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.has_billing_account" class="doc doc-heading"> <code class="highlight language-python"><span class="n">has_billing_account</span> <span class="o">=</span> <span class="kc">False</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.has_billing_account" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Whether the user has a billing account with the payment provider, made when they first bought credits. Their purchase history and receipts can be opened only then; buying for an organization does not give its other members one.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.id" class="doc doc-heading"> <code class="highlight language-python"><span class="nb">id</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Unique identifier of the user</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.organization_id" class="doc doc-heading"> <code class="highlight language-python"><span class="n">organization_id</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.organization_id" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization the account belongs to (every account belongs to exactly one). Distinct from <code>organization</code>, the free-text affiliation on the profile.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.organization_name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">organization_name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.organization_name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The display name of the organization the account belongs to.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.organization_role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">organization_role</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.organization_role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The account's role in that organization: owner, admin or member.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.pending_consents" class="doc doc-heading"> <code class="highlight language-python"><span class="n">pending_consents</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.pending_consents" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Documents (and versions) the user must still accept.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.permissions" class="doc doc-heading"> <code class="highlight language-python"><span class="n">permissions</span> <span class="o">=</span> <span class="p">[]</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.permissions" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>List of permissions assigned to the user.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserOut.role" class="doc doc-heading"> <code class="highlight language-python"><span class="n">role</span> <span class="o">=</span> <span class="n">Role</span><span class="o">.</span><span class="n">USER</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserOut.role" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's authorization role (user or admin). Distinct from billing; governs what the user may do.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserProfileUpdate" class="doc doc-heading"> <code>UserProfileUpdate</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserProfileUpdate" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Self-service profile update (account page).</p> <p>Omitted (<code>None</code>) fields are left unchanged. <code>name</code> cannot be blanked — accounts that have a name keep one; <code>position</code> may be cleared by sending an empty string. Email/password changes go through their dedicated, verified flows, and <code>usage_type</code> changes are admin-mediated (they switch the licence the user must consent to).</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="name = None pydantic-field (yousleep_common.models.authentication.UserProfileUpdate.name)" href="authentication/#yousleep_common.models.authentication.UserProfileUpdate.name">name</a></code> (<code><span title="typing.Annotated">Annotated</span>[<span title="str">str</span>, <span title="pydantic.Field">Field</span>(max_length=100), <a class="autorefs autorefs-internal" title="StripAndRequire = AfterValidator(_strip_and_require) module-attribute (yousleep_common.fields.StripAndRequire)" href="../fields/#yousleep_common.fields.StripAndRequire">StripAndRequire</a>] | None</code>) </li> <li> <code><a class="autorefs autorefs-internal" title="position = None pydantic-field (yousleep_common.models.authentication.UserProfileUpdate.position)" href="authentication/#yousleep_common.models.authentication.UserProfileUpdate.position">position</a></code> (<code><span title="str">str</span> | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserProfileUpdate.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserProfileUpdate.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's name, as they wish to be addressed. A single name is fine — no first/last split is required.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserProfileUpdate.position" class="doc doc-heading"> <code class="highlight language-python"><span class="n">position</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserProfileUpdate.position" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's position/role in their organization. An empty string clears the field.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.UserRegistration" class="doc doc-heading"> <code>UserRegistration</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.UserRegistration" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><a class="autorefs autorefs-internal" title="UserAuthentication pydantic-model (yousleep_common.models.authentication.UserAuthentication)" href="authentication/#yousleep_common.models.authentication.UserAuthentication">UserAuthentication</a></code>, <code><a class="autorefs autorefs-internal" title="UserInformation pydantic-model (yousleep_common.models.authentication.UserInformation)" href="authentication/#yousleep_common.models.authentication.UserInformation">UserInformation</a></code></p> <p>Model for self-registration (request access).</p> <p>Overrides the vetting fields inherited from <code>UserInformation</code> as required: a request-access application must identify who is asking and why. <code>position</code> stays optional. Whether <code>usage_type</code> values are currently selectable (e.g. <code>CLINICAL</code> is not) is enforced by the api-server, not this schema.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="position = None pydantic-field (yousleep_common.models.authentication.UserRegistration.position)" href="#yousleep_common.models.UserInformation.position">position</a></code> (<code>None | <span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.authentication.UserRegistration.email)" href="#yousleep_common.models.UserAuthentication.email">email</a></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="password pydantic-field (yousleep_common.models.authentication.UserRegistration.password)" href="authentication/#yousleep_common.models.authentication.UserRegistration.password">password</a></code> (<code><a class="autorefs autorefs-internal" title="NewPasswordStr = Annotated[str, Field(min_length=8, max_length=72), AfterValidator(_fits_bcrypt_limit)] module-attribute (yousleep_common.fields.NewPasswordStr)" href="../fields/#yousleep_common.fields.NewPasswordStr">NewPasswordStr</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="name pydantic-field (yousleep_common.models.authentication.UserRegistration.name)" href="authentication/#yousleep_common.models.authentication.UserRegistration.name">name</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="organization pydantic-field (yousleep_common.models.authentication.UserRegistration.organization)" href="authentication/#yousleep_common.models.authentication.UserRegistration.organization">organization</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="usage_type pydantic-field (yousleep_common.models.authentication.UserRegistration.usage_type)" href="authentication/#yousleep_common.models.authentication.UserRegistration.usage_type">usage_type</a></code> (<code><a class="autorefs autorefs-internal" title="UsageType (yousleep_common.types.UsageType)" href="../types/#yousleep_common.types.UsageType">UsageType</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="purpose pydantic-field (yousleep_common.models.authentication.UserRegistration.purpose)" href="authentication/#yousleep_common.models.authentication.UserRegistration.purpose">purpose</a></code> (<code><span title="str">str</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="accepts pydantic-field (yousleep_common.models.authentication.UserRegistration.accepts)" href="authentication/#yousleep_common.models.authentication.UserRegistration.accepts">accepts</a></code> (<code><span title="list">list</span>[<a class="autorefs autorefs-internal" title="ConsentAcceptItem pydantic-model (yousleep_common.models.consent.ConsentAcceptItem)" href="consent/#yousleep_common.models.consent.ConsentAcceptItem">ConsentAcceptItem</a>]</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserRegistration.accepts" class="doc doc-heading"> <code class="highlight language-python"><span class="n">accepts</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserRegistration.accepts" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Legal documents accepted at registration (document + version). The server records these and validates the versions.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserRegistration.name" class="doc doc-heading"> <code class="highlight language-python"><span class="n">name</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserRegistration.name" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's name, as they wish to be addressed. A single name is fine — no first/last split is required.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserRegistration.organization" class="doc doc-heading"> <code class="highlight language-python"><span class="n">organization</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserRegistration.organization" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The organization, lab, or company the user is affiliated with. Use 'Independent' if none. The part before the first comma also names the organization created for the account, cut to 64 characters at a word boundary when longer; the full text stays on the profile.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserRegistration.password" class="doc doc-heading"> <code class="highlight language-python"><span class="n">password</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserRegistration.password" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The password of the user. Must be at least 8 characters long and at most 72 bytes (bcrypt's limit). Other requirements are enforced by the backend.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserRegistration.purpose" class="doc doc-heading"> <code class="highlight language-python"><span class="n">purpose</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserRegistration.purpose" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>What the user plans to use the platform for — the basis for request-access review.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.UserRegistration.usage_type" class="doc doc-heading"> <code class="highlight language-python"><span class="n">usage_type</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.UserRegistration.usage_type" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The user's primary intended use of the platform.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.VerificationEmailRequest" class="doc doc-heading"> <code>VerificationEmailRequest</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.VerificationEmailRequest" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>Request a new email-confirmation link for an address.</p> <p>The answer is the same whether or not an account with the address exists, so the request cannot be used to probe for accounts.</p> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="email pydantic-field (yousleep_common.models.authentication.VerificationEmailRequest.email)" href="authentication/#yousleep_common.models.authentication.VerificationEmailRequest.email">email</a></code> (<code><span title="pydantic.EmailStr">EmailStr</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.VerificationEmailRequest.email" class="doc doc-heading"> <code class="highlight language-python"><span class="n">email</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.VerificationEmailRequest.email" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The address of the account to confirm.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.WalletBalance" class="doc doc-heading"> <code>WalletBalance</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.WalletBalance" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>One of an organization's two credit balances.</p> <p>Config:</p> <ul> <li><code>from_attributes</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="balance = 0 pydantic-field (yousleep_common.models.credit.WalletBalance.balance)" href="credit/#yousleep_common.models.credit.WalletBalance.balance">balance</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="held = 0 pydantic-field (yousleep_common.models.credit.WalletBalance.held)" href="credit/#yousleep_common.models.credit.WalletBalance.held">held</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletBalance.available" class="doc doc-heading"> <code class="highlight language-python"><span class="n">available</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-property"><code>property</code></small> </span> <a href="#yousleep_common.models.WalletBalance.available" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits a new analysis may use: the balance less what is held.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletBalance.balance" class="doc doc-heading"> <code class="highlight language-python"><span class="n">balance</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletBalance.balance" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits in the wallet, held ones included.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletBalance.held" class="doc doc-heading"> <code class="highlight language-python"><span class="n">held</span> <span class="o">=</span> <span class="mi">0</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletBalance.held" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits held for analyses of this wallet that are still running; charged or released when each ends.</p> </div> </div> </div> </div> </div> <div class="doc doc-object doc-class"> <h2 id="yousleep_common.models.WalletQuote" class="doc doc-heading"> <code>WalletQuote</code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-model"><code>pydantic-model</code></small> </span> <a href="#yousleep_common.models.WalletQuote" class="headerlink" title="Permanent link">¶</a></h2> <div class="doc doc-contents "> <p class="doc doc-class-bases"> Bases: <code><span title="pydantic.BaseModel">BaseModel</span></code></p> <p>What a quoted cost asks of one balance.</p> <p>Research analyses are paid from <code>grants</code>, commercial ones from <code>purchased</code>; <code>blocked_reason</code> is set when that balance cannot cover the cost. The client should then point to applying for a research grant (<code>grants</code>) or to buying credits (<code>purchased</code>) rather than submitting.</p> <p>Config:</p> <ul> <li><code>frozen</code>: <code class="highlight language-python"><span class="kc">True</span></code></li> </ul> <p>Fields:</p> <ul> <li> <code><a class="autorefs autorefs-internal" title="wallet pydantic-field (yousleep_common.models.billing.WalletQuote.wallet)" href="billing/#yousleep_common.models.billing.WalletQuote.wallet">wallet</a></code> (<code><a class="autorefs autorefs-internal" title="CreditBucket (yousleep_common.types.CreditBucket)" href="../types/#yousleep_common.types.CreditBucket">CreditBucket</a></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="estimated_credits pydantic-field (yousleep_common.models.billing.WalletQuote.estimated_credits)" href="billing/#yousleep_common.models.billing.WalletQuote.estimated_credits">estimated_credits</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="available_credits pydantic-field (yousleep_common.models.billing.WalletQuote.available_credits)" href="billing/#yousleep_common.models.billing.WalletQuote.available_credits">available_credits</a></code> (<code><span title="pydantic.NonNegativeInt">NonNegativeInt</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="balance_after pydantic-field (yousleep_common.models.billing.WalletQuote.balance_after)" href="billing/#yousleep_common.models.billing.WalletQuote.balance_after">balance_after</a></code> (<code><span title="int">int</span></code>) </li> <li> <code><a class="autorefs autorefs-internal" title="blocked_reason = None pydantic-field (yousleep_common.models.billing.WalletQuote.blocked_reason)" href="billing/#yousleep_common.models.billing.WalletQuote.blocked_reason">blocked_reason</a></code> (<code><span title="typing.Literal">Literal</span>['insufficient_credits'] | None</code>) </li> </ul> <div class="doc doc-children"> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletQuote.available_credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">available_credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletQuote.available_credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits this balance has for new analyses (balance − held).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletQuote.balance_after" class="doc doc-heading"> <code class="highlight language-python"><span class="n">balance_after</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletQuote.balance_after" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>available_credits − estimated_credits. Negative iff the submission would be rejected for insufficient credits.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletQuote.blocked_reason" class="doc doc-heading"> <code class="highlight language-python"><span class="n">blocked_reason</span> <span class="o">=</span> <span class="kc">None</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletQuote.blocked_reason" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Why the submission would be rejected, or null if this balance covers it.</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletQuote.estimated_credits" class="doc doc-heading"> <code class="highlight language-python"><span class="n">estimated_credits</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletQuote.estimated_credits" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>Credits the analyses will cost from this balance (== the settled charge for the same inputs).</p> </div> </div> <div class="doc doc-object doc-attribute"> <h3 id="yousleep_common.models.WalletQuote.wallet" class="doc doc-heading"> <code class="highlight language-python"><span class="n">wallet</span></code> <span class="doc doc-labels"> <small class="doc doc-label doc-label-pydantic-field"><code>pydantic-field</code></small> </span> <a href="#yousleep_common.models.WalletQuote.wallet" class="headerlink" title="Permanent link">¶</a></h3> <div class="doc doc-contents "> <p>The balance that pays: grants or purchased.</p> </div> </div> </div> </div> </div> </div> </div> </div> </article> </div> <script>var tabs=__md_get("__tabs");if(Array.isArray(tabs))e:for(var set of document.querySelectorAll(".tabbed-set")){var labels=set.querySelector(".tabbed-labels");for(var tab of tabs)for(var label of labels.getElementsByTagName("label"))if(label.innerText.trim()===tab){var input=document.getElementById(label.htmlFor);input.checked=!0;continue e}}</script> <script>var target=document.getElementById(location.hash.slice(1));target&&target.name&&(target.checked=target.name.startsWith("__tabbed_"))</script> </div> <button type="button" class="md-top md-icon" data-md-component="top" hidden> <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M13 20h-2V8l-5.5 5.5-1.42-1.42L12 4.16l7.92 7.92-1.42 1.42L13 8z"/></svg> Back to top </button> </main> <footer class="md-footer"> <div class="md-footer-meta md-typeset"> <div class="md-footer-meta__inner md-grid"> <div class="md-copyright"> Made with <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener"> Material for MkDocs </a> </div> </div> </div> </footer> </div> <div class="md-dialog" data-md-component="dialog"> <div class="md-dialog__inner md-typeset"></div> </div> <div class="md-progress" data-md-component="progress" role="progressbar"></div> <script id="__config" type="application/json">{"annotate": null, "base": "../../..", "features": ["navigation.tabs", "navigation.tabs.sticky", "navigation.sections", "navigation.prune", "navigation.top", "navigation.indexes", "navigation.instant", "navigation.instant.progress", "toc.follow", "search.suggest", "search.highlight", "content.code.copy", "content.tabs.link"], "search": "../../../assets/javascripts/workers/search.2c215733.min.js", "tags": null, "translations": {"clipboard.copied": "Copied to clipboard", "clipboard.copy": "Copy to clipboard", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.placeholder": "Type to start searching", "search.result.term.missing": "Missing", "select.version": "Select version"}, "version": null}</script> <script src="../../../assets/javascripts/bundle.d7400e89.min.js"></script> </body> </html>