class crowd_sdk.tagme.http_client.datacls.ASRAudioEncoding(value, )

Supported audio encodings for ASR.

ALAW = 'alaw'

FLAC = 'flac'

MP3 = 'mp3'

MULAW = 'mulaw'

OPUS = 'opus'

PCM_S16LE = 'pcm_s16le'

WAV = 'wav'

class crowd_sdk.tagme.http_client.datacls.ASRHints(words: ~typing.List[str] = <factory>, enable_letters: bool = False, eou_timeout_ms: int | None = None, )

Hints options for ASR recognition.

enable_letters: bool = False

eou_timeout_ms: int | None = None

class crowd_sdk.tagme.http_client.datacls.ASRNormalizationOptions(enable: bool | None = None, profanity_filter: bool | None = None, punctuation: bool | None = None, capitalization: bool | None = None, question: bool | None = None, force_cyrillic: bool | None = None, )

Text normalization options for ASR.

capitalization: bool | None = None

enable: bool | None = None

force_cyrillic: bool | None = None

profanity_filter: bool | None = None

punctuation: bool | None = None

question: bool | None = None

class crowd_sdk.tagme.http_client.datacls.ASROptions(sample_rate: int = 16000, encoding: ASRAudioEncoding = ASRAudioEncoding.WAV, channels_count: int = 1, language: str = 'ru-RU', model: str = 'general', enable_multi_utterance: bool = True, hypotheses_count: int = 1, no_speech_timeout_ms: int | None = None, max_speech_timeout_ms: int | None = None, hints: ASRHints | None = None, speaker_separation_options: ASRSpeakerSeparationOptions | None = None, normalization_options: ASRNormalizationOptions | None = None, insight_models: List[str] | None = None, enable_vad: bool | None = None, )

ASR recognition options for SmartSpeech.

ASROptions(sample_rate=16000, encoding=ASRAudioEncoding.WAV, language=”ru-RU”)

channels_count: int = 1

enable_multi_utterance: bool = True

enable_vad: bool | None = None

encoding: ASRAudioEncoding = 'wav'

hints: ASRHints | None = None

hypotheses_count: int = 1

insight_models: List[str] | None = None

language: str = 'ru-RU'

max_speech_timeout_ms: int | None = None

model: str = 'general'

no_speech_timeout_ms: int | None = None

normalization_options: ASRNormalizationOptions | None = None

sample_rate: int = 16000

speaker_separation_options: ASRSpeakerSeparationOptions | None = None

class crowd_sdk.tagme.http_client.datacls.ASRResponse(text: str, utterances: _typing.List[crowd_sdk.tagme.http_client.datacls.Utterance] = <factory>, backend_info: ~crowd_sdk.tagme.http_client.datacls.BackendInfo | None = None, vad_events: _typing.List[crowd_sdk.tagme.http_client.datacls.VADEvent] = <factory>, insights: ~typing.List[str] = <factory>, )

ASR response with recognition results.

backend_info: BackendInfo | None = None

text: str

class crowd_sdk.tagme.http_client.datacls.ASRSpeakerSeparationOptions(enable: bool = False, enable_only_main_speaker: bool = False, count: int = 0, )

Speaker separation (diarization) options for ASR.

count: int = 0

enable: bool = False

enable_only_main_speaker: bool = False

class crowd_sdk.tagme.http_client.datacls.ActiveAssignment(assignment_id: str, task_id: str, task_name: str, project_id: str, project_name: str, organization_id: str, item_type: str, assignment_started: datetime.datetime, price: float, )

assignment_id: str

assignment_started: datetime

item_type: str

organization_id: str

price: float

project_id: str

project_name: str

task_id: str

task_name: str

class crowd_sdk.tagme.http_client.datacls.AddBonusesResponse(failed_marker_ids: Dict[str, str] = <factory>, )

class crowd_sdk.tagme.http_client.datacls.AdvancedTaskDataWithErrors(tasks: List[crowd_sdk.tagme.http_client.datacls.TaskData], project_errors: Dict[str, List[str]] | DefaultDict[str, List[str]], task_errors: Dict[str, str], )

class crowd_sdk.tagme.http_client.datacls.AssignAssignmentRequest(task_id: str, item_id: str, marker_id: str, expired_after: datetime.datetime, original_assignment_id: str | NoneType = None, price: float | NoneType = None, is_increase_overlap: bool | NoneType = None, is_release_to_pool_on_expire: bool | NoneType = None, )

expired_after: datetime

is_increase_overlap: bool | None = None

is_release_to_pool_on_expire: bool | None = None

item_id: str

marker_id: str

original_assignment_id: str | None = None

price: float | None = None

task_id: str

class crowd_sdk.tagme.http_client.datacls.AssignAssignmentsError(task_id: str, marker_id: str, message: str, )

marker_id: str

message: str

task_id: str

class crowd_sdk.tagme.http_client.datacls.AssignAssignmentsResult(failed_assign_requests: List[crowd_sdk.tagme.http_client.datacls.AssignAssignmentsError] | NoneType, )

failed_assign_requests: List[AssignAssignmentsError] | None

class crowd_sdk.tagme.http_client.datacls.AssignMultipleAssignmentRequest(task_id: str, item_id: str, markers: List[crowd_sdk.tagme.http_client.datacls.MarkerAssignment], expired_after: datetime.datetime | str, price: float | NoneType = None, is_increase_overlap: bool | NoneType = None, is_release_to_pool_on_expire: bool | NoneType = None, )

expired_after: datetime | str

is_increase_overlap: bool | None = None

is_release_to_pool_on_expire: bool | None = None

item_id: str

price: float | None = None

task_id: str

class crowd_sdk.tagme.http_client.datacls.Assignment(file_name: str | NoneType = None, item_id: str | NoneType = None, marker_id: str | NoneType = None, organization_id: str | NoneType = None, person_id: str | NoneType = None, price: float | NoneType = None, result: dict | NoneType = None, status: Literal['ACCEPTED', 'ASSIGNED', 'SKIPPED', 'EXPIRED', 'SUBMITTED', 'REJECTED'] | NoneType = None, task_id: str | NoneType = None, start_date: datetime.datetime | NoneType = None, end_date: datetime.datetime | NoneType = None, submitted_at: datetime.datetime | NoneType = None, expired_at: datetime.datetime | NoneType = None, skipped_at: datetime.datetime | NoneType = None, accepted_at: datetime.datetime | NoneType = None, rejected_at: datetime.datetime | NoneType = None, updated_date: datetime.datetime | NoneType = None, item_type: str | NoneType = None, control: dict | NoneType = None, control_passed: bool | float | int | NoneType = None, consistency: float | NoneType = None, quality: float | NoneType = None, assignment_id: str | NoneType = None, time_spent: float | NoneType = None, email: str | NoneType = None, input_data: dict | NoneType = None, enabled: bool | NoneType = True, assignment_link: str | NoneType = None, reviewer_comment: str | NoneType = None, is_review_public: bool | NoneType = None, )

accepted_at: datetime | None = None

assignment_id: str | None = None

assignment_link: str | None = None

consistency: float | None = None

control: dict | None = None

control_passed: bool | float | int | None = None

email: str | None = None

enabled: bool | None = True

end_date: datetime | None = None

expired_at: datetime | None = None

file_name: str | None = None

static from_assignment_data(user_id: str, item_data: TaskResult, assignment_data: dict, status: Literal['ACCEPTED', 'ASSIGNED', 'SKIPPED', 'EXPIRED', 'SUBMITTED', 'REJECTED'], ) → Assignment

get_quality() → float | None

get_safe_result_field(key: str, ) → Any

input_data: dict | None = None

is_review_public: bool | None = None

item_id: str | None = None

item_type: str | None = None

marker_id: str | None = None

organization_id: str | None = None

person_id: str | None = None

price: float | None = None

quality: float | None = None

rejected_at: datetime | None = None

result: dict | None = None

reviewer_comment: str | None = None

skipped_at: datetime | None = None

start_date: datetime | None = None

status: Literal['ACCEPTED', 'ASSIGNED', 'SKIPPED', 'EXPIRED', 'SUBMITTED', 'REJECTED'] | None = None

submitted_at: datetime | None = None

task_id: str | None = None

time_spent: float | None = None

to_result_data() → Dict[str, Any]

to_skip_data() → Dict[str, Any]

updated_date: datetime | None = None

class crowd_sdk.tagme.http_client.datacls.AssignmentCorrectionRedirectResponse(assignment_id: str, )

assignment_id: str

class crowd_sdk.tagme.http_client.datacls.AssignmentCorrectionResponse(new_assignment_id: str, )

new_assignment_id: str

class crowd_sdk.tagme.http_client.datacls.AssignmentIncident(id: str, created_at: datetime.datetime, message: Dict, )

created_at: datetime

id: str

message: Dict

class crowd_sdk.tagme.http_client.datacls.AssignmentIndex(prev_assignment_id: str | NoneType = None, next_assignment_id: str | NoneType = None, )

next_assignment_id: str | None = None

prev_assignment_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.AssignmentResultByMarker(id: str, task_id: str, project_name: str, brief_url: str, file_url: str, form_url: str, result: Dict[str, Any], reviewer_comment: str | NoneType, status: str, method_id: str | NoneType = None, started_at: datetime.datetime | NoneType = None, submitted_at: datetime.datetime | NoneType = None, )

brief_url: str

file_url: str

form_url: str

id: str

method_id: str | None = None

project_name: str

reviewer_comment: str | None

started_at: datetime | None = None

status: str

submitted_at: datetime | None = None

task_id: str

class crowd_sdk.tagme.http_client.datacls.AvailableProjectTask(task_id: str, task_name: str, project_id: str, project_name: str, organization_id: str, pool_ids: List[str], )

organization_id: str

project_id: str

project_name: str

task_id: str

task_name: str

class crowd_sdk.tagme.http_client.datacls.AvailableProjectTaskResponse(has_next: bool, items: List[crowd_sdk.tagme.http_client.datacls.AvailableProjectTask], )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.BackendInfo(model_name: str = '', model_version: str = '', server_version: str = '', )

ASR backend information.

model_name: str = ''

model_version: str = ''

server_version: str = ''

class crowd_sdk.tagme.http_client.datacls.BriefReadStatusData(read_at: str, is_new_version: bool, )

is_new_version: bool

read_at: str

class crowd_sdk.tagme.http_client.datacls.BriefVersionInfo(method_id: str, created_at: datetime.datetime, file_id: str | NoneType = None, dataset_id: str | NoneType = None, version: int | NoneType = None, person: dict | NoneType = None, person_id: str | NoneType = None, is_autoupdate: bool = False, )

created_at: datetime

dataset_id: str | None = None

file_id: str | None = None

is_autoupdate: bool = False

method_id: str

person: dict | None = None

person_id: str | None = None

version: int | None = None

class crowd_sdk.tagme.http_client.datacls.CheckPluginTemplateResult(bundle: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, status: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, documentation: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, description: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, contacts: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, title: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, )

bundle: CheckResult | None = None

contacts: CheckResult | None = None

description: CheckResult | None = None

documentation: CheckResult | None = None

status: CheckResult | None = None

title: CheckResult | None = None

class crowd_sdk.tagme.http_client.datacls.CheckResult(status: crowd_sdk.tagme.http_client.datacls.CheckStatus, message: str | NoneType = None, )

message: str | None = None

class crowd_sdk.tagme.http_client.datacls.CheckStatus(value, )

An enumeration.

ERROR = 'ERROR'

OK = 'OK'

WARNING = 'WARNING'

class crowd_sdk.tagme.http_client.datacls.CheckTaskResult(brief: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, form: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, markers: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, price: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, data_count: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, filter: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, control_count: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, out_skill: crowd_sdk.tagme.http_client.datacls.SkillCheckResult | NoneType = None, data_classification_level: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, data_source: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, control_fraction: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, )

brief: CheckResult | None = None

control_count: CheckResult | None = None

control_fraction: CheckResult | None = None

data_classification_level: CheckResult | None = None

data_count: CheckResult | None = None

data_source: CheckResult | None = None

filter: CheckResult | None = None

form: CheckResult | None = None

markers: CheckResult | None = None

out_skill: SkillCheckResult | None = None

price: CheckResult | None = None

class crowd_sdk.tagme.http_client.datacls.CheckTemplateResult(brief: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, form: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, documentation: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, categories: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, contacts: crowd_sdk.tagme.http_client.datacls.CheckResult | NoneType = None, )

brief: CheckResult | None = None

categories: CheckResult | None = None

contacts: CheckResult | None = None

documentation: CheckResult | None = None

form: CheckResult | None = None

class crowd_sdk.tagme.http_client.datacls.Contacts(contacts: str | NoneType, )

contacts: str | None

class crowd_sdk.tagme.http_client.datacls.CreateOrganizationConfiguration(mms_business_task_id: str, mms_model_version_id: str, )

mms_business_task_id: str

mms_model_version_id: str

class crowd_sdk.tagme.http_client.datacls.DataGalaxyDatasetData(dataset: crowd_sdk.tagme.http_client.datacls.DataGalaxyDatasetInfo, data: List[Dict[str, Any]], )

class crowd_sdk.tagme.http_client.datacls.DataGalaxyDatasetInfo(id: str, created_at: datetime.datetime, updated_at: datetime.datetime, title: str, records_count: int, )

created_at: datetime

id: str

records_count: int

title: str

updated_at: datetime

class crowd_sdk.tagme.http_client.datacls.DataGalaxyDatasetsList(items: List[crowd_sdk.tagme.http_client.datacls.DataGalaxyDatasetInfo], next_offset: int, total_count: int, )

next_offset: int

total_count: int

class crowd_sdk.tagme.http_client.datacls.Dataset(id: str, access: str, owner_id: str, created_date: datetime.datetime, files_count: int, name: str, data_classification_level: str | NoneType = None, data_source: str | NoneType = None, acl: List[str] | NoneType = None, attachments_access: str | NoneType = None, attachments_acl: List[str] | NoneType = None, author: dict | NoneType = None, )

access: str

acl: List[str] | None = None

attachments_access: str | None = None

attachments_acl: List[str] | None = None

author: dict | None = None

created_date: datetime

data_classification_level: str | None = None

data_source: str | None = None

files_count: int

id: str

name: str

owner_id: str

class crowd_sdk.tagme.http_client.datacls.DatasetFile(url: str, name: str, id: str, dataset_id: str | NoneType = None, author: dict | NoneType = None, )

author: dict | None = None

dataset_id: str | None = None

id: str

name: str

url: str

class crowd_sdk.tagme.http_client.datacls.DatasetRequest(name: str, data_classification_level: str | NoneType = None, data_source: str | NoneType = None, )

data_classification_level: str | None = None

data_source: str | None = None

name: str

class crowd_sdk.tagme.http_client.datacls.DatasetType(value, )

An enumeration.

BUCKET = 'BUCKET'

BUNDLE = 'BUNDLE'

DATASET = 'DATASET'

LORA_LEARNING = 'LORA_LEARNING'

METHODICS = 'METHODICS'

TEMPLATE = 'TEMPLATE'

class crowd_sdk.tagme.http_client.datacls.DeleteAllFilesrResult(count: int, message: str, status: str, )

count: int

message: str

status: str

class crowd_sdk.tagme.http_client.datacls.DeleteSomeFilesResult(errors: List[dict], deleted_files: List[str], message: str, )

message: str

class crowd_sdk.tagme.http_client.datacls.Emotions(positive: float = 0.0, neutral: float = 0.0, negative: float = 0.0, positive_a: float = 0.0, neutral_a: float = 0.0, negative_a: float = 0.0, positive_t: float = 0.0, neutral_t: float = 0.0, negative_t: float = 0.0, )

Emotion analysis results.

negative: float = 0.0

negative_a: float = 0.0

negative_t: float = 0.0

neutral: float = 0.0

neutral_a: float = 0.0

neutral_t: float = 0.0

positive: float = 0.0

positive_a: float = 0.0

positive_t: float = 0.0

class crowd_sdk.tagme.http_client.datacls.Employee(person_id: str, organization_id: str, uid: str, employ_date: Union[datetime.datetime, NoneType], active: bool, roles: Union[List[str], NoneType] = None, profile: Dict[str, Any] = <factory>, report: Dict[str, Any] = <factory>, config: Dict[str, Any] = <factory>, person: Union[crowd_sdk.tagme.http_client.datacls.Person, NoneType] = None, pools: Union[List[crowd_sdk.tagme.http_client.datacls.EmployeePool], NoneType] = None, )

active: bool

employ_date: datetime | None

organization_id: str

person: Person | None = None

person_id: str

pools: List[EmployeePool] | None = None

roles: List[str] | None = None

uid: str

class crowd_sdk.tagme.http_client.datacls.EmployeePool(name: str, uid: str, )

name: str

uid: str

class crowd_sdk.tagme.http_client.datacls.EouReason(value, )

Reason for end of utterance.

MAX_SPEECH_TIMEOUT = 'max_speech_timeout'

NO_SPEECH_TIMEOUT = 'no_speech_timeout'

ORGANIC = 'organic'

UNSPECIFIED = 'unspecified'

class crowd_sdk.tagme.http_client.datacls.ErrorMarkersResponse(status: int, errors: List[crowd_sdk.tagme.http_client.datacls.MarkersError], )

status: int

class crowd_sdk.tagme.http_client.datacls.ExampleData(filename: str | Dict | NoneType = '', explanation: str | NoneType = None, control: Dict[str, Any] | NoneType = None, premarkup: Dict[str, Any] | NoneType = None, )

control: Dict[str, Any] | None = None

explanation: str | None = None

filename: str | Dict | None = ''

premarkup: Dict[str, Any] | None = None

class crowd_sdk.tagme.http_client.datacls.ExportFormat(value, )

An enumeration.

CSV = 'csv'

JSON = 'json'

TSV = 'tsv'

XLS = 'xls'

class crowd_sdk.tagme.http_client.datacls.ExportTypes(value, )

An enumeration.

MARKERS = 'MARKERS'

TASKS = 'TASKS'

class crowd_sdk.tagme.http_client.datacls.File(filename: str, uid: str, )

filename: str

uid: str

class crowd_sdk.tagme.http_client.datacls.FileError(filename: str, status: int, error: str, )

error: str

filename: str

status: int

class crowd_sdk.tagme.http_client.datacls.FileMetaData(file_id: str, filehash: str | NoneType = None, premarkup: dict | NoneType = None, control: dict | NoneType = None, explanation: Any | NoneType = None, )

control: dict | None = None

explanation: Any | None = None

file_id: str

filehash: str | None = None

premarkup: dict | None = None

class crowd_sdk.tagme.http_client.datacls.FileType(value, )

An enumeration.

CONTROL = 'CONTROL'

DATA = 'DATA'

STUDY = 'STUDY'

class crowd_sdk.tagme.http_client.datacls.FullOrganization(uid: str, name: str, creation_date: datetime.datetime | NoneType = None, config: crowd_sdk.tagme.http_client.datacls.OrganizationConfig | NoneType = None, active_employees_cnt: int | NoneType = None, all_employees_cnt: int | NoneType = None, employees: List[crowd_sdk.tagme.http_client.datacls.OrganizationEmployee] | NoneType = None, is_demo: bool | NoneType = None, contacts: str | NoneType = None, is_vendor: bool | NoneType = None, currency: str | NoneType = None, conversion_rate: float | NoneType = None, confidential_category: List[str] | NoneType = None, customer_contacts: str | NoneType = None, )

active_employees_cnt: int | None = None

all_employees_cnt: int | None = None

confidential_category: List[str] | None = None

config: OrganizationConfig | None = None

contacts: str | None = None

conversion_rate: float | None = None

creation_date: datetime | None = None

currency: str | None = None

customer_contacts: str | None = None

employees: List[OrganizationEmployee] | None = None

is_demo: bool | None = None

is_vendor: bool | None = None

name: str

uid: str

class crowd_sdk.tagme.http_client.datacls.GetMarkerVendorsItem(vendor_id: str, name: str, is_active: bool | NoneType = None, )

is_active: bool | None = None

name: str

vendor_id: str

class crowd_sdk.tagme.http_client.datacls.GetMarkerVendorsResponse(items: List[crowd_sdk.tagme.http_client.datacls.GetMarkerVendorsItem], )

class crowd_sdk.tagme.http_client.datacls.GetProjectPublicAssignmentsResponse(project_id: str, project_name: str, assignments: List[crowd_sdk.tagme.http_client.datacls.PublicAssignmentItem], )

project_id: str

project_name: str

class crowd_sdk.tagme.http_client.datacls.HourlyTaskConsistencyStatistics(datetime: datetime.datetime, period_started_at: datetime.datetime, task_id: str, item_consistency_sum: float, item_consistency_count: int, )

datetime: datetime

item_consistency_count: int

item_consistency_sum: float

period_started_at: datetime

task_id: str

class crowd_sdk.tagme.http_client.datacls.HourlyTaskMarkerStatistics(datetime: datetime.datetime, period_started_at: datetime.datetime, task_id: str, marker_id: str, expired_count: int, skipped_count: int, accepted_count: int, rejected_count: int, submitted_count: int, markup_duration_sec: float, consistency_sum: float, consistency_count: int, quality_sum: float, quality_count: int, payed_money_sum: float, payed_money_count: int, frozen_money_sum: float, rejected_money_sum: float, )

accepted_count: int

consistency_count: int

consistency_sum: float

datetime: datetime

expired_count: int

frozen_money_sum: float

marker_id: str

markup_duration_sec: float

payed_money_count: int

payed_money_sum: float

period_started_at: datetime

quality_count: int

quality_sum: float

rejected_count: int

rejected_money_sum: float

skipped_count: int

submitted_count: int

task_id: str

class crowd_sdk.tagme.http_client.datacls.ImageResult(uid: str, file_name: str, file_size_bytes: int, )

file_name: str

file_size_bytes: int

uid: str

class crowd_sdk.tagme.http_client.datacls.InstalledPlugin(plugin_template_id: str, plugin_assignment_id: str, template_roles: List[Literal['MARKER', 'CUSTOMER', 'ORGANIZATION_ADMIN']], roles: List[Literal['MARKER', 'CUSTOMER', 'ORGANIZATION_ADMIN']], enabled: bool, route: str, name: str, template_organization_id: str, scope: Literal['SIDEBAR'], created_at: datetime.datetime, description: str, )

created_at: datetime

description: str

enabled: bool

name: str

plugin_assignment_id: str

plugin_template_id: str

route: str

template_organization_id: str

class crowd_sdk.tagme.http_client.datacls.InterfaceVersionInfo(method_id: str, version: int, created_at: datetime.datetime, person_id: str | NoneType = None, is_autoupdate: bool | NoneType = False, updated_keys: List[str] | NoneType = None, person: dict | NoneType = None, config_content: dict | NoneType = None, config_base_version: int | NoneType = None, specification_content: dict | NoneType = None, specification_base_version: int | NoneType = None, html_content: str | NoneType = None, html_base_version: int | NoneType = None, css_content: str | NoneType = None, css_base_version: int | NoneType = None, js_content: str | NoneType = None, js_base_version: int | NoneType = None, example_content: dict | NoneType = None, example_base_version: int | NoneType = None, )

config_base_version: int | None = None

config_content: dict | None = None

created_at: datetime

css_base_version: int | None = None

css_content: str | None = None

example_base_version: int | None = None

example_content: dict | None = None

html_base_version: int | None = None

html_content: str | None = None

is_autoupdate: bool | None = False

js_base_version: int | None = None

js_content: str | None = None

method_id: str

person: dict | None = None

person_id: str | None = None

specification_base_version: int | None = None

specification_content: dict | None = None

updated_keys: List[str] | None = None

version: int

class crowd_sdk.tagme.http_client.datacls.InviteApplication(state: str, invite_id: str, created_date: datetime.datetime, person_id: str, uid: str, invite_name: str | NoneType, person: crowd_sdk.tagme.http_client.datacls.InvitePerson | NoneType, )

created_date: datetime

invite_id: str

invite_name: str | None

person: InvitePerson | None

person_id: str

state: str

uid: str

class crowd_sdk.tagme.http_client.datacls.InviteData(state: str, current_new_requests_count: int, acceptance_strategy: str, organization_id: str, expired_date: datetime.datetime | NoneType, uid: str, current_requests_count: int, invite_name: str, max_requests_count: int | NoneType, created_date: datetime.datetime, author_id: str, pools_to_assign: List[str] | NoneType, auto_accept_emails: str | NoneType, )

acceptance_strategy: str

author_id: str

auto_accept_emails: str | None

created_date: datetime

current_new_requests_count: int

current_requests_count: int

expired_date: datetime | None

invite_name: str

max_requests_count: int | None

organization_id: str

pools_to_assign: List[str] | None

state: str

uid: str

class crowd_sdk.tagme.http_client.datacls.InvitePerson(email: str, first_name: str, last_name: str, middle_name: str | NoneType, phone_number: str | NoneType, source_platform: str | NoneType, )

email: str

first_name: str

last_name: str

middle_name: str | None

phone_number: str | None

source_platform: str | None

class crowd_sdk.tagme.http_client.datacls.InviteRequest(acceptance_strategy: str, organization_id: str, invite_name: str, state: str | NoneType = None, max_requests_count: int | NoneType = None, expired_date: datetime.datetime | NoneType = None, pools_to_assign: List[str] | NoneType = None, auto_accept_emails: str | NoneType = None, )

acceptance_strategy: str

auto_accept_emails: str | None = None

expired_date: datetime | None = None

invite_name: str

max_requests_count: int | None = None

organization_id: str

pools_to_assign: List[str] | None = None

state: str | None = None

class crowd_sdk.tagme.http_client.datacls.Item(stat: crowd_sdk.tagme.http_client.datacls.ItemStat, )

class crowd_sdk.tagme.http_client.datacls.ItemStat(task_overlap: int, in_progress: int, in_review: int, rejected: int, accepted: int, overlap: int | NoneType = None, )

accepted: int

in_progress: int

in_review: int

overlap: int | None = None

rejected: int

task_overlap: int

class crowd_sdk.tagme.http_client.datacls.MarkerActiveAssignmentResponse(assignments: List[crowd_sdk.tagme.http_client.datacls.ActiveAssignment], )

class crowd_sdk.tagme.http_client.datacls.MarkerAssignment(marker_id: str, original_assignment_id: str | NoneType = None, )

marker_id: str

original_assignment_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.MarkerPool(marker_id: str, pool_id: str, priority: int | NoneType = None, )

marker_id: str

pool_id: str

priority: int | None = None

class crowd_sdk.tagme.http_client.datacls.MarkerSkill(uid: str, name: str, person_id: str, organization_id: str, value: int, created_date: datetime.datetime | NoneType, person: crowd_sdk.tagme.http_client.datacls.Person | NoneType, )

created_date: datetime | None

name: str

organization_id: str

person: Person | None

person_id: str

uid: str

value: int

class crowd_sdk.tagme.http_client.datacls.MarkerSkillDataError(code: str, message: str, value: Any | NoneType, row: int, )

code: str

message: str

row: int

value: Any | None

class crowd_sdk.tagme.http_client.datacls.MarkerSkillUpdated(person: str, skill: str, row: int, )

person: str

row: int

skill: str

class crowd_sdk.tagme.http_client.datacls.MarkerStatInProject(marker_id: str, total_money: float, marking_duration_secs: int, )

marker_id: str

marking_duration_secs: int

total_money: float

class crowd_sdk.tagme.http_client.datacls.MarkerStats(items: List[crowd_sdk.tagme.http_client.datacls.MarkerStatInProject], )

class crowd_sdk.tagme.http_client.datacls.MarkersError(email_list: List[str], error_message: str, )

error_message: str

class crowd_sdk.tagme.http_client.datacls.MarkersStatistic(date: str, organization: str, project: str, project_id: str, task: str, task_id: str, marker_id: str, avg_time: float, overall_time: float, blocked_price: float | NoneType = None, sum_price: float | NoneType = None, fio: str | NoneType = None, email: str | NoneType = None, begin: datetime.datetime | NoneType = None, end: datetime.datetime | NoneType = None, marked: int = 0, skipped: int = 0, accepted: int = 0, rejected: int = 0, submitted: int = 0, expired: int = 0, avg_quality: float | NoneType = None, avg_consistency: float | NoneType = None, rejected_price: float | NoneType = None, bonus_plus_penalty: float | NoneType = None, count_quality: int | NoneType = None, vendor_id: str | NoneType = None, )

accepted: int = 0

avg_consistency: float | None = None

avg_quality: float | None = None

avg_time: float

begin: datetime | None = None

blocked_price: float | None = None

bonus_plus_penalty: float | None = None

count_quality: int | None = None

date: str

email: str | None = None

end: datetime | None = None

expired: int = 0

fio: str | None = None

marked: int = 0

marker_id: str

organization: str

overall_time: float

project: str

project_id: str

rejected: int = 0

rejected_price: float | None = None

skipped: int = 0

submitted: int = 0

sum_price: float | None = None

task: str

task_id: str

vendor_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.MarkupMarkerStatistic(stat_at: datetime.date, task_type: crowd_sdk.tagme.http_client.datacls.TaskType, marking_duration: int, marked: int, accepted: int, accepted_money: float, frozen: int, frozen_money: float, project_id: str, project_name: str, skills: List[crowd_sdk.tagme.http_client.datacls.MarkupMarkerStatisticSkill], vendor_id: str | NoneType = None, currency: str | NoneType = None, bonus_money: float | NoneType = None, penalty_money: float | NoneType = None, )

accepted: int

accepted_money: float

bonus_money: float | None = None

currency: str | None = None

frozen: int

frozen_money: float

marked: int

marking_duration: int

penalty_money: float | None = None

project_id: str

project_name: str

stat_at: date

vendor_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.MarkupMarkerStatisticSkill(id: str, name: str, level: int, )

id: str

level: int

name: str

class crowd_sdk.tagme.http_client.datacls.MarkupMarkerStatistics(items: List[crowd_sdk.tagme.http_client.datacls.MarkupMarkerStatistic], has_next: bool, )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.MarkupMarkerStatisticsSortField(value, )

An enumeration.

STAT_AT = 'stat_at'

class crowd_sdk.tagme.http_client.datacls.MarkupResult(id: str, project_id: str, task_id: str, marker_id: str, items: List[crowd_sdk.tagme.http_client.datacls.MarkupResultItem], status: str, start_date: datetime.datetime, end_date: datetime.datetime | NoneType, quality: float | NoneType, consistency: float | NoneType, result: dict | NoneType, submitted_at: datetime.datetime | NoneType, accepted_at: datetime.datetime | NoneType, skipped_at: datetime.datetime | NoneType, expired_at: datetime.datetime | NoneType, rejected_at: datetime.datetime | NoneType, reviewer_id: str | NoneType, reviewer_comment: str | NoneType, original_assignment_id: str | NoneType, is_review_public: bool | NoneType, has_incidents: bool | NoneType = None, incidents: List[crowd_sdk.tagme.http_client.datacls.AssignmentIncident] | NoneType = None, )

accepted_at: datetime | None

consistency: float | None

end_date: datetime | None

expired_at: datetime | None

has_incidents: bool | None = None

id: str

incidents: List[AssignmentIncident] | None = None

is_review_public: bool | None

marker_id: str

original_assignment_id: str | None

project_id: str

quality: float | None

rejected_at: datetime | None

result: dict | None

reviewer_comment: str | None

reviewer_id: str | None

skipped_at: datetime | None

start_date: datetime

status: str

submitted_at: datetime | None

task_id: str

class crowd_sdk.tagme.http_client.datacls.MarkupResultItem(id: str, type: str, file_name: str, control: Dict | NoneType, )

control: Dict | None

file_name: str

id: str

type: str

class crowd_sdk.tagme.http_client.datacls.MarkupResultSortField(value, )

An enumeration.

ACCEPTED = 'accepted'

CONSISTENCY = 'consistency'

EXPIRED = 'expired'

ITEM_ID = 'item_id'

ITEM_TYPE = 'item_type'

MARKUP_DURATION = 'markup_duration'

QUALITY = 'quality'

REJECTED = 'rejected'

SKIPPED = 'skipped'

STATUS = 'status'

SUBMITTED = 'submitted'

class crowd_sdk.tagme.http_client.datacls.MarkupResults(items: List[crowd_sdk.tagme.http_client.datacls.MarkupResult], has_next: bool, )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.MarkupReview(assignment_id: str, status: str | NoneType = None, comment: str | NoneType = None, is_review_public: bool | NoneType = None, quality: float | NoneType = None, is_delete_quality_when_empty: bool | NoneType = None, is_delete_comment_when_empty: bool | NoneType = None, )

assignment_id: str

comment: str | None = None

is_delete_comment_when_empty: bool | None = None

is_delete_quality_when_empty: bool | None = None

is_review_public: bool | None = None

quality: float | None = None

status: str | None = None

class crowd_sdk.tagme.http_client.datacls.MarkupReviewResult(failed_assignment_ids: Dict[str, str] | NoneType, )

failed_assignment_ids: Dict[str, str] | None

class crowd_sdk.tagme.http_client.datacls.MarkupTask(id: str, project_name: str, assignment_timeout_seconds: float, skippable: bool, brief_url: str, file_url: str, form_url: str, premarkup_url: str, price: float, item_id: str, empty: bool = False, started_at: datetime.datetime | NoneType = None, currency: str | NoneType = None, )

assignment_timeout_seconds: float

brief_url: str

static build_empty_task() → MarkupTask

currency: str | None = None

empty: bool = False

file_url: str

form_url: str

id: str

item_id: str

premarkup_url: str

price: float

project_name: str

skippable: bool

started_at: datetime | None = None

class crowd_sdk.tagme.http_client.datacls.MarkupTaskFile(name: str, content_type: str, content: aiohttp.streams.StreamReader, _MarkupTaskFile__bytes: bytes | NoneType = None, )

async as_dict() → Any

content: StreamReader

content_type: str

name: str

async read() → bytes

async save(path: Path | str, ) → Path

class crowd_sdk.tagme.http_client.datacls.Member(uid: str, person: 'Person', priority: int | NoneType = None, )

priority: int | None = None

uid: str

class crowd_sdk.tagme.http_client.datacls.MetaData(control: dict | NoneType = None, premarkup: dict | NoneType = None, explanation: Any | NoneType = None, )

control: dict | None = None

explanation: Any | None = None

premarkup: dict | None = None

class crowd_sdk.tagme.http_client.datacls.MetaErrorItem(id: str, assignment_id: str, item_id: str, task_id: str, project_id: str, organization_id: str, message: dict, created_at: datetime.datetime, )

assignment_id: str

created_at: datetime

id: str

item_id: str

message: dict

organization_id: str

project_id: str

task_id: str

class crowd_sdk.tagme.http_client.datacls.MetaErrors(items: List[crowd_sdk.tagme.http_client.datacls.MetaErrorItem], has_next: bool, )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.MetaType(value, )

An enumeration.

CONTROL = 'control'

EXPLANATION = 'explanation'

PREMARKUP = 'premarkup'

class crowd_sdk.tagme.http_client.datacls.MethodData(uid: str, name: str | NoneType = None, forms: crowd_sdk.tagme.http_client.datacls.MethodForms | NoneType = None, marker_brief: str | NoneType = None, organization_id: str | NoneType = None, person_id: str | NoneType = None, modification_date: str | NoneType = None, is_brief_as_url: bool | NoneType = None, brief_update_date: str | NoneType = None, forms_update_date: str | NoneType = None, config_update_date: str | NoneType = None, )

brief_update_date: str | None = None

config_update_date: str | None = None

forms: MethodForms | None = None

forms_update_date: str | None = None

is_brief_as_url: bool | None = None

marker_brief: str | None = None

modification_date: str | None = None

name: str | None = None

organization_id: str | None = None

person_id: str | None = None

uid: str

class crowd_sdk.tagme.http_client.datacls.MethodDataRequest(uid: str, name: str | NoneType = None, forms: crowd_sdk.tagme.http_client.datacls.MethodFormsRequest | NoneType = None, marker_brief: str | NoneType = None, organization_id: str | NoneType = None, person_id: str | NoneType = None, modification_date: str | NoneType = None, is_brief_as_url: bool | NoneType = None, brief_update_date: str | NoneType = None, forms_update_date: str | NoneType = None, config_update_date: str | NoneType = None, )

brief_update_date: str | None = None

config_update_date: str | None = None

forms: MethodFormsRequest | None = None

forms_update_date: str | None = None

is_brief_as_url: bool | None = None

marker_brief: str | None = None

modification_date: str | None = None

name: str | None = None

organization_id: str | None = None

person_id: str | None = None

uid: str

class crowd_sdk.tagme.http_client.datacls.MethodFileType(value, )

An enumeration.

BRIEF = 'brief'

class crowd_sdk.tagme.http_client.datacls.MethodForms(example: dict = <factory>, config: dict = <factory>, specification: dict = <factory>, html: Union[str, NoneType] = '', css: Union[str, NoneType] = '', js: Union[str, NoneType] = '', )

config: dict

css: str | None = ''

example: dict

html: str | None = ''

js: str | None = ''

specification: dict

class crowd_sdk.tagme.http_client.datacls.MethodFormsRequest(example: dict | NoneType = None, config: dict | NoneType = None, specification: dict | NoneType = None, html: str | NoneType = None, css: str | NoneType = None, js: str | NoneType = None, )

config: dict | None = None

css: str | None = None

example: dict | None = None

html: str | None = None

js: str | None = None

specification: dict | None = None

class crowd_sdk.tagme.http_client.datacls.Model(uid: str, created_at: datetime.datetime, name: str, description: str, project_id: str, dataset_id: str, author_id: str, organization_id: str, train_id: str | NoneType = None, test_id: str | NoneType = None, )

author_id: str

created_at: datetime

dataset_id: str

description: str

name: str

organization_id: str

project_id: str

test_id: str | None = None

train_id: str | None = None

uid: str

class crowd_sdk.tagme.http_client.datacls.ModelCreateRequest(name: str, description: str, project_id: str, dataset_id: str, train_id: str | NoneType = None, test_id: str | NoneType = None, )

dataset_id: str

description: str

name: str

project_id: str

test_id: str | None = None

train_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.Organization(uid: str, name: str, employ_date: Union[datetime.datetime, NoneType], employee_id: str, roles: List[str] = <factory>, profile: Dict[str, Any] = <factory>, report: Dict[str, Any] = <factory>, config: Dict[str, Any] = <factory>, )

employ_date: datetime | None

employee_id: str

name: str

uid: str

class crowd_sdk.tagme.http_client.datacls.OrganizationConfig(help_center_url: str | NoneType, marker_faq_url: str | NoneType, price_instruction_lnk: str | NoneType, )

help_center_url: str | None

marker_faq_url: str | None

price_instruction_lnk: str | None

class crowd_sdk.tagme.http_client.datacls.OrganizationConfiguration(mms_business_task_id: str, mms_model_version_id: str, business_task_name: str | NoneType = None, model_name: str | NoneType = None, model_version_confidentional_category: str | NoneType = None, organization_id: str | NoneType = None, )

business_task_name: str | None = None

mms_business_task_id: str

mms_model_version_id: str

model_name: str | None = None

model_version_confidentional_category: str | None = None

organization_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.OrganizationEmployee(first_name: str, last_name: str, uid: str, )

first_name: str

last_name: str

uid: str

class crowd_sdk.tagme.http_client.datacls.OrganizationStatistic(projects_count: int | NoneType = None, projects_with_active_tasks: int | NoneType = None, opened_tasks: int | NoneType = None, done_tasks: int | NoneType = None, marked_count: int | NoneType = None, unmarked_count: int | NoneType = None, pools_count: int | NoneType = None, markers_pools_count: int | NoneType = None, validators_pools_count: int | NoneType = None, markers_count: int | NoneType = None, validators_count: int | NoneType = None, )

done_tasks: int | None = None

marked_count: int | None = None

markers_count: int | None = None

markers_pools_count: int | None = None

opened_tasks: int | None = None

pools_count: int | None = None

projects_count: int | None = None

projects_with_active_tasks: int | None = None

unmarked_count: int | None = None

validators_count: int | None = None

validators_pools_count: int | None = None

class crowd_sdk.tagme.http_client.datacls.OverlapSource(value, )

An enumeration.

FROM_TASK = 'FROM_TASK'

USER_DEFINED = 'USER_DEFINED'

class crowd_sdk.tagme.http_client.datacls.Person(email: str, first_name: str, last_name: str, uid: str, middle_name: str | NoneType = None, organizations: List[crowd_sdk.tagme.http_client.datacls.Organization] | NoneType = None, phone_number: str | NoneType = None, source_platform: str | NoneType = None, partner_id: str | NoneType = None, utm_referral: str | NoneType = None, vendor_id: str | NoneType = None, )

email: str

first_name: str

get_config(organization: str, ) → Dict[str, Any] | None

get_fio() → str

get_organization(organization: str, ) → Organization | None

get_profile(organization: str, ) → Dict[str, Any] | None

get_report(organization: str, ) → Dict[str, Any] | None

get_roles(organization: str, ) → List[str] | None

last_name: str

middle_name: str | None = None

organizations: List[Organization] | None = None

partner_id: str | None = None

phone_number: str | None = None

source_platform: str | None = None

uid: str

utm_referral: str | None = None

vendor_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.PersonVendorInfo(vendor_id: str, vendor_name: str, contacts: str | NoneType = None, )

contacts: str | None = None

vendor_id: str

vendor_name: str

class crowd_sdk.tagme.http_client.datacls.Plugin(type: crowd_sdk.tagme.http_client.datacls.PluginTypes, route: str, icon: str, title: str, bundle: str, data: dict | NoneType, )

bundle: str

data: dict | None

icon: str

route: str

title: str

class crowd_sdk.tagme.http_client.datacls.PluginAssignment(uid: str, plugin_template_id: str, organization_id: str, roles: List[Literal['MARKER', 'CUSTOMER', 'ORGANIZATION_ADMIN']], enabled: bool, route: str, icon_file_id: str, created_at: datetime.datetime, skipped_person_ids: List[dict], )

created_at: datetime

enabled: bool

icon_file_id: str

organization_id: str

plugin_template_id: str

route: str

uid: str

class crowd_sdk.tagme.http_client.datacls.PluginInstallation(plugin_assignment_id: str, organization_id: str, organization_name: str, roles: List[Literal['MARKER', 'CUSTOMER', 'ORGANIZATION_ADMIN']], )

organization_id: str

organization_name: str

plugin_assignment_id: str

class crowd_sdk.tagme.http_client.datacls.PluginTemplate(uid: str, name: str, person_id: str, organization_id: str, access: Literal['public', 'organization', 'private'], acl: List[str] | NoneType, status: Literal['DRAFT', 'PUBLISHED', 'ARCHIVED'], scope: Literal['SIDEBAR'], roles: List[Literal['MARKER', 'CUSTOMER', 'ORGANIZATION_ADMIN']], description: str | NoneType, contacts: str | NoneType, title: str | NoneType, icon_file_id: str, bundle_file_id: str, preview_file_id: str, installations_count: int, created_at: datetime.datetime, updated_at: datetime.datetime, documentation: str | NoneType = None, config: dict | NoneType = None, )

acl: List[str] | None

bundle_file_id: str

config: dict | None = None

contacts: str | None

created_at: datetime

description: str | None

documentation: str | None = None

icon_file_id: str

installations_count: int

name: str

organization_id: str

person_id: str

preview_file_id: str

title: str | None

uid: str

updated_at: datetime

class crowd_sdk.tagme.http_client.datacls.PluginTemplateFileResult(template_file_id: str, )

template_file_id: str

class crowd_sdk.tagme.http_client.datacls.PluginTypes(value, )

An enumeration.

CUSTOMER = 'CUSTOMER'

MARKER = 'MARKER'

class crowd_sdk.tagme.http_client.datacls.Pool(name: str, uid: str, person_id: str, person: Union[ForwardRef('Person'), NoneType] = None, members_count: Union[int, NoneType] = 0, members: List[crowd_sdk.tagme.http_client.datacls.Member] = <factory>, organization_id: Union[str, NoneType] = None, organization: Union[crowd_sdk.tagme.http_client.datacls.PoolOrganization, NoneType] = None, access: Union[Literal['public', 'organization', 'private'], NoneType] = None, acl: Union[List[str], NoneType] = None, group_type: Literal['MARKERS', 'VALIDATORS'] = 'MARKERS', )

access: Literal['public', 'organization', 'private'] | None = None

acl: List[str] | None = None

group_type: Literal['MARKERS', 'VALIDATORS'] = 'MARKERS'

members_count: int | None = 0

name: str

organization: PoolOrganization | None = None

organization_id: str | None = None

person: Person | None = None

person_id: str

uid: str

class crowd_sdk.tagme.http_client.datacls.PoolOrganization(uid: str, name: str, )

name: str

uid: str

class crowd_sdk.tagme.http_client.datacls.PreviewFileResult(preview_file_id: str, )

preview_file_id: str

class crowd_sdk.tagme.http_client.datacls.Project(organization_id: str, name: str, description: str, inner_comment: str, pools: List[str], uid: str, method_id: str, person_id: str, created_date: datetime.datetime | NoneType, update_date: datetime.datetime | NoneType, running_tasks_count: int | NoneType, tasks_count: int | NoneType, is_archived: bool = False, method: Union[ForwardRef('MethodData'), NoneType] = None, is_bookmarked: bool = False, pipeline: dict | NoneType = None, is_pipeline_enabled: bool | NoneType = False, template_id: str | NoneType = None, is_brief_autoupdate: bool | NoneType = False, is_forms_autoupdate: bool | NoneType = False, is_config_autoupdate: bool | NoneType = False, is_specification_autoupdate: bool | NoneType = False, markers_count_plan: int | NoneType = None, pipeline_errors: str | NoneType = None, contacts: str | NoneType = None, )

contacts: str | None = None

created_date: datetime | None

description: str

inner_comment: str

is_archived: bool = False

is_bookmarked: bool = False

is_brief_autoupdate: bool | None = False

is_config_autoupdate: bool | None = False

is_forms_autoupdate: bool | None = False

is_pipeline_enabled: bool | None = False

is_specification_autoupdate: bool | None = False

markers_count_plan: int | None = None

method: MethodData | None = None

method_id: str

name: str

organization_id: str

person_id: str

pipeline: dict | None = None

pipeline_errors: str | None = None

running_tasks_count: int | None

tasks_count: int | None

template_id: str | None = None

uid: str

update_date: datetime | None

class crowd_sdk.tagme.http_client.datacls.ProjectStat(avg_income: float | NoneType, min_price: float | NoneType, max_price: float | NoneType, study_price: float | NoneType, exam_price: float | NoneType, )

avg_income: float | None

exam_price: float | None

max_price: float | None

min_price: float | None

study_price: float | None

class crowd_sdk.tagme.http_client.datacls.ProjectStatistic(project_id: str, markers_count: int | NoneType = None, validators_count: int | NoneType = None, pools_count: int | NoneType = None, markers_pools_count: int | NoneType = None, validators_pools_count: int | NoneType = None, objects_count: int | NoneType = None, marked_count: int | NoneType = None, status: str | NoneType = None, tasks_count: int | NoneType = None, active_marker_count: int | NoneType = None, )

active_marker_count: int | None = None

marked_count: int | None = None

markers_count: int | None = None

markers_pools_count: int | None = None

objects_count: int | None = None

pools_count: int | None = None

project_id: str

status: str | None = None

tasks_count: int | None = None

validators_count: int | None = None

validators_pools_count: int | None = None

class crowd_sdk.tagme.http_client.datacls.ProjectStatistics(min_price: float | NoneType = None, max_price: float | NoneType = None, min_study_price: float | NoneType = None, max_study_price: float | NoneType = None, min_exam_price: float | NoneType = None, max_exam_price: float | NoneType = None, min_retry_price: float | NoneType = None, max_retry_price: float | NoneType = None, )

max_exam_price: float | None = None

max_price: float | None = None

max_retry_price: float | None = None

max_study_price: float | None = None

min_exam_price: float | None = None

min_price: float | None = None

min_retry_price: float | None = None

min_study_price: float | None = None

class crowd_sdk.tagme.http_client.datacls.ProjectTask(id: str, status: TaskStatus, description: str, form_url: str, brief_url: str, is_favourite_project: bool, project_name: str, project_id: str, price: float, type: TaskType, project_stat: ProjectStatistics, is_auto_accept: bool, method_id: str | None = None, started_at: datetime | None = None, min_expired_after: datetime | None = None, priority: int | None = None, max_income: float | None = None, avg_time: float | None = None, project_description: str | None = None, currency: str | None = None, )

Project-task entity

avg_time: float | None = None

brief_url: str

currency: str | None = None

description: str

form_url: str

id: str

is_auto_accept: bool

is_favourite_project: bool

max_income: float | None = None

method_id: str | None = None

min_expired_after: datetime | None = None

price: float

priority: int | None = None

project_description: str | None = None

project_id: str

project_name: str

started_at: datetime | None = None

class crowd_sdk.tagme.http_client.datacls.ProjectTaskPaginated(items: List[crowd_sdk.tagme.http_client.datacls.ProjectTask], has_next: bool, )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.ProjectsWithPublicAssignment(project_id: str, project_name: str, last_updated_at: datetime.datetime, )

last_updated_at: datetime

project_id: str

project_name: str

class crowd_sdk.tagme.http_client.datacls.PublicAssignmentItem(id: str, task_id: str, status: crowd_sdk.tagme.http_client.datacls.ReviewStatus, updated_at: datetime.datetime, reviewer_comment: str | NoneType = None, reviewer_id: str | NoneType = None, )

id: str

reviewer_comment: str | None = None

reviewer_id: str | None = None

task_id: str

updated_at: datetime

class crowd_sdk.tagme.http_client.datacls.PublicSkill(id: str, value: int, count: int, )

count: int

id: str

value: int

class crowd_sdk.tagme.http_client.datacls.ReviewStatus(value, )

An enumeration.

ACCEPTED = 'ACCEPTED'

REJECTED = 'REJECTED'

SUBMITTED = 'SUBMITTED'

class crowd_sdk.tagme.http_client.datacls.SPInfo(report_url: str, checking_files_count: int, rejected_files_count: int, error_files_count: int, )

checking_files_count: int

error_files_count: int

rejected_files_count: int

report_url: str

class crowd_sdk.tagme.http_client.datacls.SetMarkerSkillResponse(value: int, person_id: str, skill_id: str, )

person_id: str

skill_id: str

value: int

class crowd_sdk.tagme.http_client.datacls.SetMarkersSkillsResponse(data_errors: List[crowd_sdk.tagme.http_client.datacls.MarkerSkillDataError] | NoneType, updated_skills: List[crowd_sdk.tagme.http_client.datacls.MarkerSkillUpdated], )

data_errors: List[MarkerSkillDataError] | None

class crowd_sdk.tagme.http_client.datacls.SimpleImagesListResult(images: List[crowd_sdk.tagme.http_client.datacls.ImageResult], )

class crowd_sdk.tagme.http_client.datacls.Skill(uid: str, name: str, person_id: str, window_size: int | NoneType = 64, enabled: bool = True, organization_id: str | NoneType = None, marker_count: int | NoneType = None, created_date: datetime.datetime | NoneType = None, is_public: bool = False, )

created_date: datetime | None = None

enabled: bool = True

is_public: bool = False

marker_count: int | None = None

name: str

organization_id: str | None = None

person_id: str

uid: str

window_size: int | None = 64

class crowd_sdk.tagme.http_client.datacls.SkillCheckResult(status: crowd_sdk.tagme.http_client.datacls.CheckStatus, message: str | NoneType = None, uid: str | NoneType = None, )

uid: str | None = None

class crowd_sdk.tagme.http_client.datacls.SortOrder(value, )

An enumeration.

ASC = 'asc'

DESC = 'desc'

class crowd_sdk.tagme.http_client.datacls.SpeakerInfo(speaker_id: int, main_speaker_confidence: float = 0.0, )

Speaker diarization information.

main_speaker_confidence: float = 0.0

speaker_id: int

class crowd_sdk.tagme.http_client.datacls.TTSAudioEncoding(value, )

Supported audio encodings for TTS.

ALAW = 'alaw'

G729 = 'g729'

OPUS = 'opus'

PCM_S16LE = 'pcm_s16le'

WAV = 'wav'

class crowd_sdk.tagme.http_client.datacls.TTSContentType(value, )

Content type for TTS input.

SSML = 'ssml'

TEXT = 'text'

class crowd_sdk.tagme.http_client.datacls.TTSRequest(text: str, content_type: TTSContentType = TTSContentType.TEXT, voice: str = 'May_24000', language: str = 'ru-RU', audio_encoding: TTSAudioEncoding = TTSAudioEncoding.WAV, )

TTS request options for SmartSpeech synthesis.

TTSRequest(text=”Привет, мир!”, voice=”May_24000”, audio_encoding=TTSAudioEncoding.WAV)

audio_encoding: TTSAudioEncoding = 'wav'

content_type: TTSContentType = 'text'

language: str = 'ru-RU'

text: str

voice: str = 'May_24000'

class crowd_sdk.tagme.http_client.datacls.TaskBonus(author_id: str, bonus: float, bonus_at: datetime.date, comment: str, id: str, marker_id: str, task_id: str, average_quality: float | NoneType = None, marked_count: int | NoneType = None, marking_duration_secs: float | NoneType = None, vendor_id: str | NoneType = None, )

author_id: str

average_quality: float | None = None

bonus: float

bonus_at: date

comment: str

id: str

marked_count: int | None = None

marker_id: str

marking_duration_secs: float | None = None

task_id: str

vendor_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.TaskBonuses(items: List[crowd_sdk.tagme.http_client.datacls.TaskBonus], has_next: bool, )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.TaskBonusesSummary(bonus_summary: float, penalty_summary: float, )

bonus_summary: float

penalty_summary: float

class crowd_sdk.tagme.http_client.datacls.TaskData(project_id: str, organization_id: Union[str, NoneType], name: str, uid: str, person_id: str, estimated_files_count: Union[int, NoneType], storage_id: Union[str, NoneType], item_timeout_seconds: Union[int, NoneType], use_project_method: Union[bool, NoneType], payload: Union[dict, NoneType], data_classification_level: Union[str, NoneType], data_source: Union[str, NoneType], control_count: Union[int, NoneType], control_fraction: Union[int, NoneType], created_date: Union[datetime.datetime, NoneType], update_date: Union[datetime.datetime, NoneType], start_date: Union[datetime.datetime, NoneType], finished_date: Union[datetime.datetime, NoneType], out_skill_id: Union[str, NoneType], deadline: Union[datetime.date, NoneType], expected_consistency: Union[float, NoneType], expected_quality: Union[float, NoneType], expected_sum: Union[float, NoneType], filter: Union[dict, NoneType], type: crowd_sdk.tagme.http_client.datacls.TaskType = <TaskType.PROD: 'PROD'>, state: crowd_sdk.tagme.http_client.datacls.TaskState = <TaskState.INITIAL: 'INITIAL'>, is_active: bool = False, overlap: int = 1, skip_strategy: crowd_sdk.tagme.http_client.datacls.TaskSkipStrategy = <TaskSkipStrategy.NON_SKIPPABLE: 'NON_SKIPPABLE'>, deleted: bool = False, description: Union[str, NoneType] = '', depersonalize: bool = False, price: float = 0, priority: int = 0, is_auto_accept: bool = True, auto_accept_period_day: Union[int, NoneType] = None, auto_accept_threshold: Union[float, NoneType] = None, is_straight_order: bool = False, max_items_per_day: Union[int, NoneType] = None, attachments_access: Union[str, NoneType] = None, attachments_acl: Union[List[str], NoneType] = None, markers_count_plan: Union[int, NoneType] = None, )

attachments_access: str | None = None

attachments_acl: List[str] | None = None

auto_accept_period_day: int | None = None

auto_accept_threshold: float | None = None

control_count: int | None

control_fraction: int | None

created_date: datetime | None

data_classification_level: str | None

data_source: str | None

deadline: date | None

deleted: bool = False

depersonalize: bool = False

description: str | None = ''

estimated_files_count: int | None

expected_consistency: float | None

expected_quality: float | None

expected_sum: float | None

filter: dict | None

finished_date: datetime | None

gen_url(base_url: str, ) → str

is_active: bool = False

is_auto_accept: bool = True

is_straight_order: bool = False

item_timeout_seconds: int | None

markers_count_plan: int | None = None

max_items_per_day: int | None = None

name: str

organization_id: str | None

out_skill_id: str | None

overlap: int = 1

payload: dict | None

person_id: str

price: float = 0

priority: int = 0

project_id: str

skip_strategy: TaskSkipStrategy = 'NON_SKIPPABLE'

start_date: datetime | None

state: TaskState = 'INITIAL'

storage_id: str | None

type: TaskType = 'PROD'

uid: str

update_date: datetime | None

use_project_method: bool | None

class crowd_sdk.tagme.http_client.datacls.TaskDataRequest(project_id: str, organization_id: str, name: str, overlap: int = 1, type: crowd_sdk.tagme.http_client.datacls.TaskType = <TaskType.PROD: 'PROD'>, skip_strategy: crowd_sdk.tagme.http_client.datacls.TaskSkipStrategy = <TaskSkipStrategy.NON_SKIPPABLE: 'NON_SKIPPABLE'>, description: Union[str, NoneType] = '', price: Union[float, NoneType] = None, priority: Union[int, NoneType] = None, data_classification_level: Union[str, NoneType] = None, data_source: Union[str, NoneType] = None, control_count: Union[int, NoneType] = None, control_fraction: Union[int, NoneType] = None, item_timeout_seconds: Union[int, NoneType] = None, out_skill_id: Union[str, NoneType] = None, depersonalize: Union[bool, NoneType] = None, deadline: Union[datetime.date, NoneType] = None, expected_consistency: Union[float, NoneType] = None, expected_quality: Union[float, NoneType] = None, expected_sum: Union[float, NoneType] = None, filter: Union[dict, NoneType] = None, is_auto_accept: bool = True, auto_accept_period_day: Union[int, NoneType] = None, auto_accept_threshold: Union[float, NoneType] = None, is_straight_order: bool = False, max_items_per_day: Union[int, NoneType] = None, attachments_access: Union[str, NoneType] = None, attachments_acl: Union[List[str], NoneType] = None, markers_count_plan: Union[int, NoneType] = None, )

attachments_access: str | None = None

attachments_acl: List[str] | None = None

auto_accept_period_day: int | None = None

auto_accept_threshold: float | None = None

control_count: int | None = None

control_fraction: int | None = None

data_classification_level: str | None = None

data_source: str | None = None

deadline: date | None = None

depersonalize: bool | None = None

description: str | None = ''

expected_consistency: float | None = None

expected_quality: float | None = None

expected_sum: float | None = None

filter: dict | None = None

classmethod from_task_data(task_data: TaskData, ignore_fields: Set[str] | None = None, ) → TaskDataRequest

is_auto_accept: bool = True

is_straight_order: bool = False

item_timeout_seconds: int | None = None

markers_count_plan: int | None = None

max_items_per_day: int | None = None

name: str

organization_id: str

out_skill_id: str | None = None

overlap: int = 1

price: float | None = None

priority: int | None = None

project_id: str

skip_strategy: TaskSkipStrategy = 'NON_SKIPPABLE'

type: TaskType = 'PROD'

class crowd_sdk.tagme.http_client.datacls.TaskFile(content_type: str, name: str, size: int, metadata: List[crowd_sdk.tagme.http_client.datacls.MetaType], bucket: str, hashsum: str | NoneType, data: str | NoneType, uid: str, file_type: crowd_sdk.tagme.http_client.datacls.FileType, enabled: bool | NoneType, )

bucket: str

content_type: str

data: str | None

enabled: bool | None

hashsum: str | None

name: str

size: int

uid: str

class crowd_sdk.tagme.http_client.datacls.TaskFilesCount(all: int | NoneType = None, control: int | NoneType = None, study: int | NoneType = None, data: int | NoneType = None, )

all: int | None = None

control: int | None = None

data: int | None = None

study: int | None = None

class crowd_sdk.tagme.http_client.datacls.TaskHierarchy(project_id: str, organization_id: str, template_id: str | NoneType, )

organization_id: str

project_id: str

template_id: str | None

class crowd_sdk.tagme.http_client.datacls.TaskInfo(id: str, status: TaskStatus, started_at: datetime | None = None, )

Minified task entity

id: str

started_at: datetime | None = None

class crowd_sdk.tagme.http_client.datacls.TaskMarkup(pools: List[str], pick_date: datetime.datetime, submit_date: datetime.datetime, result: Dict[str, Any], )

pick_date: datetime

submit_date: datetime

class crowd_sdk.tagme.http_client.datacls.TaskResult(uid: str, entity_id: str, task_id: str, organization_id: str, person_id: str, storage_id: Union[str, NoneType], file_name: str, entity_type: Union[str, NoneType], price: Union[float, NoneType], skip: Dict[str, Any] = <factory>, result: Dict[str, Dict[str, Any]] = <factory>, consistency_percentage: Union[float, NoneType] = None, consistent_result: Union[bool, NoneType] = None, consistent_skip: Union[bool, NoneType] = None, )

append_assignment(assignment: Assignment, ) → None

consistency_percentage: float | None = None

consistent_result: bool | None = None

consistent_skip: bool | None = None

entity_id: str

entity_type: str | None

file_name: str

classmethod from_assignments(item_id: str, assignments: List[Assignment], ) → TaskResult

organization_id: str

person_id: str

price: float | None

storage_id: str | None

task_id: str

to_dict() → dict

uid: str

class crowd_sdk.tagme.http_client.datacls.TaskResultsValidationInfo(latest_results: List[crowd_sdk.tagme.http_client.datacls.ValidationTaskResult], latest_statuses: List[crowd_sdk.tagme.http_client.datacls.ValidationTaskStatus], )

class crowd_sdk.tagme.http_client.datacls.TaskSkipStrategy(value, )

An enumeration.

COUNT_AS_MARKUP = 'COUNT_AS_MARKUP'

IGNORE = 'IGNORE'

NON_SKIPPABLE = 'NON_SKIPPABLE'

class crowd_sdk.tagme.http_client.datacls.TaskState(value, )

An enumeration.

ARCHIVE = 'ARCHIVE'

DONE = 'DONE'

INITIAL = 'INITIAL'

RUNNING = 'RUNNING'

STOPPED = 'STOPPED'

class crowd_sdk.tagme.http_client.datacls.TaskStatistics(assigned: int, submitted: int, accepted: int, rejected: int, )

accepted: int

assigned: int

rejected: int

submitted: int

class crowd_sdk.tagme.http_client.datacls.TaskStatisticsItem(task_id: str, objects_count: int, marked_count: int, total_marked_objects_count: int, total_skipped_objects_count: int, total_expired_objects_count: int, total_accepted_objects_count: int, total_rejected_objects_count: int, total_submitted_objects_count: int, total_marked_time: float, current_overlap: float, total_objects_count: float, overlap_marked_stats: Dict[str, Any], updated_date: datetime.datetime | NoneType, )

current_overlap: float

marked_count: int

objects_count: int

task_id: str

total_accepted_objects_count: int

total_expired_objects_count: int

total_marked_objects_count: int

total_marked_time: float

total_objects_count: float

total_rejected_objects_count: int

total_skipped_objects_count: int

total_submitted_objects_count: int

updated_date: datetime | None

class crowd_sdk.tagme.http_client.datacls.TaskStats(task_id: str, total_marked_time: float, objects_count: int, marked_count: int, total_skipped_objects_count: int, total_marked_objects_count: int, total_accepted_objects_count: int, total_rejected_objects_count: int, current_overlap: int, total_objects_count: int, avg_object_count_marker: float, status: crowd_sdk.tagme.http_client.datacls.TaskState, one_object_avg_time: float, active_markers: int, total_markers: int, finished_marker: int | NoneType, pretending_marker: int | NoneType, cost: float | NoneType, avg_quality: float | NoneType, avg_consistency: float | NoneType, avg_hour_profit: float | NoneType, avg_accepted_price: float | NoneType, avg_rejected_price: float | NoneType, )

active_markers: int

avg_accepted_price: float | None

avg_consistency: float | None

avg_hour_profit: float | None

avg_object_count_marker: float

avg_quality: float | None

avg_rejected_price: float | None

cost: float | None

current_overlap: int

finished_marker: int | None

marked_count: int

objects_count: int

one_object_avg_time: float

pretending_marker: int | None

task_id: str

total_accepted_objects_count: int

total_marked_objects_count: int

total_marked_time: float

total_markers: int

total_objects_count: int

total_rejected_objects_count: int

total_skipped_objects_count: int

class crowd_sdk.tagme.http_client.datacls.TaskStatsAdvanced(estimation_date: datetime.date | NoneType, in_progress_count: int, )

estimation_date: date | None

in_progress_count: int

class crowd_sdk.tagme.http_client.datacls.TaskStatus(value, )

An enumeration.

ARCHIVE = 'ARCHIVE'

RUN = 'RUN'

STOP = 'STOP'

class crowd_sdk.tagme.http_client.datacls.TaskTabItemStats(item_id: str, task_overlap: int, overlap: int, in_progress: int, in_review: int, rejected: int, accepted: int, assigned: int, queue: int, overlap_source: crowd_sdk.tagme.http_client.datacls.OverlapSource, )

accepted: int

assigned: int

in_progress: int

in_review: int

item_id: str

overlap: int

queue: int

rejected: int

task_overlap: int

class crowd_sdk.tagme.http_client.datacls.TaskType(value, )

An enumeration.

EXAM = 'EXAM'

HONEYPOT = 'HONEYPOT'

PROD = 'PROD'

RETRY = 'RETRY'

STUDY = 'STUDY'

class crowd_sdk.tagme.http_client.datacls.TaskUnavailabilityReason(reason_code: crowd_sdk.tagme.http_client.datacls.TaskUnavailabilityReasonCode, reason_description: str, )

reason_description: str

class crowd_sdk.tagme.http_client.datacls.TaskUnavailabilityReasonCode(value, )

An enumeration.

ALREADY_MARKED = 'ALREADY_MARKED'

AVAILABLE = 'AVAILABLE'

DAILY_LIMIT_REACHED = 'DAILY_LIMIT_REACHED'

INACTIVE_TASK = 'INACTIVE_TASK'

LOW_POOL_PRIORITY_LEVEL = 'LOW_POOL_PRIORITY_LEVEL'

MORE_IMPORTANT_TASK_AVAILABLE = 'MORE_IMPORTANT_TASK_AVAILABLE'

NOT_FOR_VENDOR = 'NOT_FOR_VENDOR'

NOT_IN_POOL = 'NOT_IN_POOL'

NO_TASK = 'NO_TASK'

UNDEFINED = 'UNDEFINED'

UNSUITABLE_SKILL_LEVEL = 'UNSUITABLE_SKILL_LEVEL'

class crowd_sdk.tagme.http_client.datacls.TaskflowTaskData(id: str, brief_url: str, project_name: str, description: str, project_description: str | NoneType, form_url: str, price: float, status: str, type: str, project_stat: crowd_sdk.tagme.http_client.datacls.ProjectStat, is_auto_accept: bool, currency: str | NoneType = None, )

brief_url: str

currency: str | None = None

description: str

form_url: str

id: str

is_auto_accept: bool

price: float

project_description: str | None

project_name: str

status: str

type: str

class crowd_sdk.tagme.http_client.datacls.TasksStatistic(date: str, organization: str, project: str, project_id: str, task: str, task_id: str, overlap: int, avg_time: float, overall_time: float, count_assignments: int = 0, count_items: int = 0, completed_items: int = 0, completed_assignments: int = 0, accepted_assignments: int = 0, rejected_assignments: int = 0, submitted_assignments: int = 0, skipped_assignments: int = 0, expired_assignments: int = 0, sum_price: float | NoneType = None, blocked_price: float | NoneType = None, avg_consistency: float | NoneType = None, avg_quality: float | NoneType = None, task_type: str | NoneType = None, rejected_price: float | NoneType = None, bonus_plus_penalty: float | NoneType = None, count_quality: int | NoneType = None, )

accepted_assignments: int = 0

avg_consistency: float | None = None

avg_quality: float | None = None

avg_time: float

blocked_price: float | None = None

bonus_plus_penalty: float | None = None

completed_assignments: int = 0

completed_items: int = 0

count_assignments: int = 0

count_items: int = 0

count_quality: int | None = None

date: str

expired_assignments: int = 0

organization: str

overall_time: float

overlap: int

project: str

project_id: str

rejected_assignments: int = 0

rejected_price: float | None = None

skipped_assignments: int = 0

submitted_assignments: int = 0

sum_price: float | None = None

task: str

task_id: str

task_type: str | None = None

class crowd_sdk.tagme.http_client.datacls.Template(uid: str, name: str, person_id: str, organization_id: str, status: str, method_id: str, preview_file_id: str | NoneType = '', description: str | NoneType = '', categories: List[str] | NoneType = None, gallery_ids: List[str] | NoneType = None, created_at: datetime.datetime | NoneType = None, updated_at: datetime.datetime | NoneType = None, documentation: str | NoneType = '', dataset_id: str | NoneType = None, contacts: str | NoneType = None, projects_count: int | NoneType = 0, access: str | NoneType = None, acl: List[str] | NoneType = None, )

access: str | None = None

acl: List[str] | None = None

categories: List[str] | None = None

contacts: str | None = None

created_at: datetime | None = None

dataset_id: str | None = None

description: str | None = ''

documentation: str | None = ''

gallery_ids: List[str] | None = None

method_id: str

name: str

organization_id: str

person_id: str

preview_file_id: str | None = ''

projects_count: int | None = 0

status: str

uid: str

updated_at: datetime | None = None

class crowd_sdk.tagme.http_client.datacls.TypeCasting

class crowd_sdk.tagme.http_client.datacls.UpdateMetaDataRequest(data: crowd_sdk.tagme.http_client.datacls.MetaData, fileId: str | NoneType = None, filename: str | NoneType = None, )

fileId: str | None = None

filename: str | None = None

class crowd_sdk.tagme.http_client.datacls.UploadFilesResult(created_files: List[crowd_sdk.tagme.http_client.datacls.File] = <factory>, errors: List[Union[crowd_sdk.tagme.http_client.datacls.FileError, str]] = <factory>, )

extend(other: UploadFilesResult, ) → None

static merge(*results: Any, ) → UploadFilesResult

class crowd_sdk.tagme.http_client.datacls.UserPlugin(title: str, route: str, icon_file_id: str, )

icon_file_id: str

route: str

title: str

class crowd_sdk.tagme.http_client.datacls.Utterance(text: str, normalized_text: str = '', start_ms: int = 0, end_ms: int = 0, words: _typing.List[crowd_sdk.tagme.http_client.datacls.WordAlignment] = <factory>, channel: int = 0, eou_reason: ~crowd_sdk.tagme.http_client.datacls.EouReason = EouReason.UNSPECIFIED, emotions: ~crowd_sdk.tagme.http_client.datacls.Emotions | None = None, speaker_info: ~crowd_sdk.tagme.http_client.datacls.SpeakerInfo | None = None, )

Single recognized utterance.

channel: int = 0

emotions: Emotions | None = None

end_ms: int = 0

eou_reason: EouReason = 'unspecified'

normalized_text: str = ''

speaker_info: SpeakerInfo | None = None

start_ms: int = 0

text: str

class crowd_sdk.tagme.http_client.datacls.VADEvent(channel: int, processed_audio_ms: int, utterance_detection_ms: int, )

Voice Activity Detection event.

channel: int

processed_audio_ms: int

utterance_detection_ms: int

class crowd_sdk.tagme.http_client.datacls.ValidateTimeStatistic(created_at: datetime.datetime, date: datetime.date, duration_sec: int, task_id: str, updated_at: datetime.datetime, validator_id: str, )

created_at: datetime

date: date

duration_sec: int

task_id: str

updated_at: datetime

validator_id: str

class crowd_sdk.tagme.http_client.datacls.ValidateTimeStatistics(items: List[crowd_sdk.tagme.http_client.datacls.ValidateTimeStatistic], has_next: bool, )

has_next: bool

class crowd_sdk.tagme.http_client.datacls.ValidationPipelineResult(status: str, validators_total: int, validators: List[dict], items_total: int | NoneType = None, validated_file_id: str | NoneType = None, errors_file_id: str | NoneType = None, )

errors_file_id: str | None = None

items_total: int | None = None

status: str

validated_file_id: str | None = None

validators_total: int

class crowd_sdk.tagme.http_client.datacls.ValidationRequestItem(source: str, options: Dict[str, Any] = <factory>, )

source: str

class crowd_sdk.tagme.http_client.datacls.ValidationTaskResult(algorithm: str, params: dict, result_file_id: str, created_at: datetime.datetime, errors_file_id: str | NoneType = None, mean_result: float | NoneType = None, )

algorithm: str

created_at: datetime

errors_file_id: str | None = None

mean_result: float | None = None

params: dict

result_file_id: str

class crowd_sdk.tagme.http_client.datacls.ValidationTaskStatus(algorithm: str, status: str, updated_at: datetime.datetime, message: str | NoneType = None, )

algorithm: str

message: str | None = None

status: str

updated_at: datetime

class crowd_sdk.tagme.http_client.datacls.ValidatorDetail(source: str, type: crowd_sdk.tagme.http_client.datacls.ValidatorType, title: str, enabled: bool, stage: str, description: str, tags: List[str], options: dict, )

description: str

enabled: bool

options: dict

source: str

stage: str

title: str

class crowd_sdk.tagme.http_client.datacls.ValidatorInfo(is_validator: bool, )

is_validator: bool

class crowd_sdk.tagme.http_client.datacls.ValidatorProject(project_id: str, project_name: str, project_description: str, available_task_count: int, )

available_task_count: int

project_description: str

project_id: str

project_name: str

class crowd_sdk.tagme.http_client.datacls.ValidatorTask(task_id: str, task_status: crowd_sdk.tagme.http_client.datacls.TaskStatus, task_name: str, task_type: crowd_sdk.tagme.http_client.datacls.TaskType, task_description: str, num_of_submitted_assignments: int, items_completed: int, items_total: int, priority: int, created_at: datetime.datetime, author_id: str | NoneType = None, auto_accept_threshold: float | NoneType = None, method_id: str | NoneType = None, )

author_id: str | None = None

auto_accept_threshold: float | None = None

created_at: datetime

items_completed: int

items_total: int

method_id: str | None = None

num_of_submitted_assignments: int

priority: int

task_description: str

task_id: str

task_name: str

class crowd_sdk.tagme.http_client.datacls.ValidatorType(value, )

An enumeration.

artifact = 'artifact'

base = 'base'

dataset_backend = 'dataset/backend'

dataset_frontend = 'dataset/frontend'

class crowd_sdk.tagme.http_client.datacls.VendorChangeRecord(person_id: str, created_at: datetime.datetime, source_platform: str | NoneType = None, partner_id: str | NoneType = None, vendor_id: str | NoneType = None, utm_referral: str | NoneType = None, active_from: datetime.datetime | NoneType = None, prev_source_platform: str | NoneType = None, prev_partner_id: str | NoneType = None, prev_vendor_id: str | NoneType = None, prev_utm_referral: str | NoneType = None, error: str | NoneType = None, )

active_from: datetime | None = None

created_at: datetime

error: str | None = None

partner_id: str | None = None

person_id: str

prev_partner_id: str | None = None

prev_source_platform: str | None = None

prev_utm_referral: str | None = None

prev_vendor_id: str | None = None

source_platform: str | None = None

utm_referral: str | None = None

vendor_id: str | None = None

class crowd_sdk.tagme.http_client.datacls.VerifyLoraConfiguration(allowed: bool, business_task_name: str | NoneType, model_version_confidentional_category: str | NoneType, )

allowed: bool

business_task_name: str | None

model_version_confidentional_category: str | None

class crowd_sdk.tagme.http_client.datacls.WordAlignment(word: str, start_ms: int, end_ms: int, )

Word timing information.

end_ms: int

start_ms: int

word: str

crowd_sdk.tagme.http_client.datacls.fmt_date(d: datetime | None, ) → str | None