class crowd_sdk.tagme.http_client.datacls.Assignment(file_name: str, item_id: str, marker_id: str, organization_id: str, person_id: str, price: float | NoneType, result: dict | NoneType, status: str, task_id: str, 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, )

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

static from_assignment_data(user_id: str, item_data: TaskResult, assignment_data: dict, status: str, ) → Assignment

get_quality() → float | None

get_safe_result_field(key: str, ) → Any

input_data: dict | None = None

item_id: str

item_type: str | None = None

marker_id: str

organization_id: str

person_id: str

price: float | None

quality: float | None = None

rejected_at: datetime | None = None

result: dict | None

reviewer_comment: str | None = None

skipped_at: datetime | None = None

start_date: datetime | None = None

status: str

submitted_at: datetime | None = None

task_id: str

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.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.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, )

access: str

acl: List[str] | 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, )

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.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.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, )

active_employees_cnt: int | None = None

all_employees_cnt: int | None = None

config: OrganizationConfig | None = None

creation_date: datetime | None = None

employees: List[OrganizationEmployee] | None = None

is_demo: bool | None = None

name: str

uid: 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.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.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.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, email: str, fio: str, avg_time: float, overall_time: float, sum_price: float, blocked_price: float, 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, )

accepted: int = 0

avg_consistency: float | None = None

avg_quality: float | None = None

avg_time: float

begin: datetime | None = None

blocked_price: float

date: str

email: str

end: datetime | None = None

expired: int = 0

fio: str

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

task: str

task_id: str

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], )

accepted: int

accepted_money: float

frozen: int

frozen_money: float

marked: int

marking_duration: int

project_id: str

project_name: str

stat_at: date

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, )

accepted_at: datetime | None

consistency: float | None

end_date: datetime | None

expired_at: datetime | None

id: str

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, quality: float | NoneType = None, )

assignment_id: str

comment: str | 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, )

assignment_timeout_seconds: float

brief_url: str

static build_empty_task() → MarkupTask

empty: bool = False

file_url: str

form_url: str

id: str

item_id: str

premarkup_url: str

price: float

project_name: str

skippable: bool

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', )

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.MetaType(value, )

An enumeration.

CONTROL = 'control'

EXPLANATION = 'explanation'

PREMARKUP = 'premarkup'

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

is_brief_as_url: bool | None = None

marker_brief: str

modification_date: str | None = None

name: str

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.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.OrganizationEmployee(first_name: str, last_name: str, uid: str, )

first_name: str

last_name: str

uid: str

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, )

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

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.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, )

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, )

created_date: datetime | None

description: str

inner_comment: str

is_archived: bool = False

is_bookmarked: bool = False

is_pipeline_enabled: bool | None = False

method: MethodData | None = None

method_id: str

name: str

organization_id: str

person_id: str

pipeline: dict | 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, pools_count: int | NoneType = None, objects_count: int | NoneType = None, marked_count: int | NoneType = None, status: str | NoneType = None, tasks_count: int | NoneType = None, )

marked_count: int | None = None

markers_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

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.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.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, )

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

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, )

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

is_auto_accept: bool = True

is_straight_order: bool = False

item_timeout_seconds: 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, )

organization_id: str

project_id: str

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.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.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, )

active_markers: int

avg_consistency: float | None

avg_object_count_marker: float

avg_quality: 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.TaskType(value, )

An enumeration.

EXAM = 'EXAM'

HONEYPOT = 'HONEYPOT'

PROD = 'PROD'

RETRY = 'RETRY'

STUDY = 'STUDY'

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, )

brief_url: str

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, count_markers: int, active_markers: int, avg_time: float, overall_time: float, sum_price: float, blocked_price: 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, avg_consistency: float | NoneType = None, avg_quality: float | NoneType = None, task_type: str | NoneType = None, rejected_price: float | NoneType = None, )

accepted_assignments: int = 0

active_markers: int

avg_consistency: float | None = None

avg_quality: float | None = None

avg_time: float

blocked_price: float

completed_assignments: int = 0

completed_items: int = 0

count_assignments: int = 0

count_items: int = 0

count_markers: int

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

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], errors: List[crowd_sdk.tagme.http_client.datacls.FileError | str], )

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