The SDK is best for writing Python scripts to interact with your RedBrick AI Organization & Projects. The SDK offers granular functions for programmatically manipulating data, importing annotations, assigning tasks, and more.
redbrick.StorageMethod
[source]
Storage method integrations for RedBrick Organizations.
PUBLIC
- Access files from a public cloud storage service using their absolute URLs.(i.e. files available publicly)
REDBRICK
- Access files stored on RedBrick AI’s servers (i.e. files uploaded directly to RBAI from a local machine)
AWSS3
- Access files stored in an external S3 bucket that has been integrated with RedBrick AI
GoogleCloud
- Access files stored in an external Google Cloud bucket that has been integrated with RedBrick AI
AzureBlob
- Access files stored in an external Azure Blob that has been integrated with RedBrick AI
AltaDB
- Access files stored in an AltaDB dataset
Public
[source]
Public storage provider (Subclass of StorageProvider
).
Variables:
redbrick.StorageMethod.PUBLIC
"Public"
redbrick.StorageMethod.Public.Details
) – Public storage method details.
Details
[source]
Public storage provider details. Subclass of Public
property key
: str
Public storage provider details key.
classmethod from_entity(entity=None)[source]
Get object from entity
Return type:
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
validate(check_secrets=False)[source]
Validate Public storage provider details.
Return type:
None
classmethod from_entity(entity)[source]
Get object from entity
Return type:
Public
class RedBrick[source]
RedBrick storage provider (Sub class of StorageProvider
).
Variables:
redbrick.StorageMethod.REDBRICK
"Direct Upload"
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
validate(check_secrets=False)[source]
Validate RedBrick storage provider details.
Return type:
None
classmethod from_entity(entity)[source]
Get object from entity
Return type:
RedBrick
class AWSS3(storage_id, name, details)[source]
AWS S3 storage provider (Sub class of StorageProvider
).
Variables:
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
validate(check_secrets=False)[source]
Validate AWS S3 storage provider details.
Return type:
None
class GoogleCloud(storage_id, name, details)[source]
Google cloud storage provider (Sub class of StorageProvider
).
Variables:
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
validate(check_secrets=False)[source]
Validate Google cloud storage provider details.
Return type:
None
class AzureBlob(storage_id, name, details)[source]
Azure blob storage provider (Sub class of StorageProvider
).
Variables:
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
validate(check_secrets=False)[source]
Validate Azure blob storage provider details.
Return type:
None
class AltaDB(storage_id, name, details)[source]
AltaDB storage provider (Sub class of StorageProvider
).
Variables:
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
validate(check_secrets=False)[source]
Validate AltaDB storage provider details.
Return type:
None
class redbrick.StorageProvider(storage_id, name, details)[source]
Base storage provider.
Public
)
RedBrick
)
AWSS3
)
GoogleCloud
)
AzureBlob
)
AltaDB
)
Details
abstract to_entity()[source]
Get entity from object.
Return type:
Dict
[str
, Any
]
abstract validate(check_secrets=False)[source]
Validate storage provider details.
Return type:
None
classmethod from_entity(entity)[source]
Get object from entity
Return type:
StorageProvider
class redbrick.ImportTypes(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]
Enumerates the supported data import types.
Please see supported data types, and file extensions in our documentation here.
class redbrick.TaskEventTypes(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]
Enumerate the different types of task events.
TASK_CREATED
- A new task has been created.
TASK_SUBMITTED
- A task has been submitted for review.
TASK_ACCEPTED
- A submitted task has been accepted in review.
TASK_REJECTED
- A submitted task has been rejected in review.
TASK_CORRECTED
- A submitted task has been corrected in review.
TASK_ASSIGNED
- A task has been assigned to a worker.
TASK_REASSIGNED
- A task has been reassigned to another worker.
TASK_UNASSIGNED
- A task has been unassigned from a worker.
TASK_SKIPPED
- A task has been skipped by a worker.
TASK_SAVED
- A task has been saved but not yet submitted.
GROUNDTRUTH_TASK_EDITED
- A ground truth task has been edited.
CONSENSUS_COMPUTED
- The consensus for a task has been computed.
COMMENT_ADDED
- A comment has been added to a task.
CONSENSUS_TASK_EDITED
- A consensus task has been edited.
ALL
- All tasks.
GROUNDTRUTH
- Ground truth tasks only.
UNASSIGNED
- Tasks that have not yet been assigned to a worker.
QUEUED
- Tasks that are queued for labeling/review.
DRAFT
- Tasks that have been saved as draft.
SKIPPED
- Tasks that have been skipped by a worker.
COMPLETED
- Tasks that have been completed successfully.
FAILED
- Tasks that have been rejected in review.
ISSUES
- Tasks that have issues raised and cannot be completed.
UNASSIGNED
- The Task has not been assigned to a Project Admin or Member.
ASSIGNED
- The Task has been assigned to a Project Admin or Member,but work has not begun on it.
IN_PROGRESS
- The Task is currently being worked on by a Project Admin or Member.
COMPLETED
- The Task has been completed successfully.
PROBLEM
- A Project Admin or Member has raised an Issue regarding the Task,and work cannot continue until the Issue is resolved by a Project Admin.
SKIPPED
- The Task has been skipped.
STAGED
- The Task has been saved as a Draft.
Config
abstract to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
abstract classmethod from_entity(entity, taxonomy=None)[source]
Get object from entity
Return type:
Stage
abstract to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
class redbrick.LabelStage(stage_name, config=<factory>, on_submit=True)[source]
Label Stage.
Parameters:
Config
to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
classmethod from_entity(entity, taxonomy=None)[source]
Get object from entity
Return type:
LabelStage
to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
class redbrick.ReviewStage(stage_name, config=<factory>, on_accept=True, on_reject=False)[source]
Review Stage.
Parameters:
Config
to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
classmethod from_entity(entity, taxonomy=None)[source]
Get object from entity
Return type:
ReviewStage
to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
class redbrick.ModelStage(stage_name, config=<factory>, on_submit=True)[source]
Model Stage.
Parameters:
Config
to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
classmethod from_entity(entity, taxonomy=None)[source]
Get object from entity
Return type:
ModelStage
to_entity(taxonomy=None)[source]
Get entity from object.
Return type:
Dict
class redbrick.OrgMember(user_id, email, given_name, family_name, role, tags, is_2fa_enabled, last_active=None, sso_provider=None)[source]
Organization Member.
Parameters:
OWNER
- Organization Owner
ADMIN
- Organization Admin
MEMBER
- Organization Member
OrgMember
class redbrick.OrgInvite(email, role, sso_provider=None, status=Status.PENDING)[source]
Organization Invite.
Parameters:
PENDING
- Pending invitation
ACCEPTED
- Accepted invitation
DECLINED
- Declined invitation
OrgInvite
to_entity()[source]
Get entity from object.
Return type:
Dict
class redbrick.ProjectMember(member_id, role, stages=None, org_membership=None)[source]
Project Member.
Parameters:
ADMIN
- Project Admin
MANAGER
- Project Manager
MEMBER
- Project Member (Labeler/Reviewer)
ProjectMember
redbrick.get_org(org_id, api_key, *url=‘https://api.redbrickai.com’*)[\[source\]](https://sdk.redbrickai.com/_modules/redbrick.html#get_org)
Get an existing redbrick organization object.
Organization object allows you to interact with your organization and perform high level actions like creating a project.
>>> org = redbrick.get_org(org_id, api_key**)**
Parameters:
RBOrganization
redbrick.get_workspace(org_id, workspace_id, api_key, *url=‘https://api.redbrickai.com’*)[\[source\]](https://sdk.redbrickai.com/_modules/redbrick.html#get_workspace)
Get an existing RedBrick workspace object.
Workspace objects allow you to interact with your RedBrick AI workspaces, and perform actions like importing data, exporting data etc.
>>> workspace = redbrick.get_workspace(org_id, workspace_id, api_key**)**
Parameters:
RBWorkspace
redbrick.get_project(org_id, project_id, api_key, *url=‘https://api.redbrickai.com’*)[\[source\]](https://sdk.redbrickai.com/_modules/redbrick.html#get_project)
Get an existing RedBrick project object.
Project objects allow you to interact with your RedBrick Ai projects, and perform actions like importing data, exporting data etc.
>>> project = redbrick.get_project(org_id, project_id, api_key**)**
Parameters:
RBProject
redbrick.get_org_from_profile(profile_name=None)[source]
Get the org from the profile name in credentials file
>>> org = get_org_from_profile()
Parameters:
profile_name (str) – Name of the profile stored in the credentials file
Return type:
RBOrganization
redbrick.get_project_from_profile(project_id=None, profile_name=None)[source]
Get the RBProject object using the credentials file
project = get_project_from_profile()
Parameters:
RBProject
ABC
Representation of RedBrick organization.
The redbrick.RBOrganization
object allows you to programmatically interact with your RedBrick organization. This class provides methods for querying your organization and doing other high level actions. Retrieve the organization object in the following way:
Variables:
Union
[List
[str
], List
[Taxonomy
]]
abstract workspaces_raw()[source]
Get a list of active workspaces as raw objects in the organization.
Return type:
List
[Dict
]
abstract projects_raw()[source]
Get a list of active projects as raw objects in the organization.
Return type:
List
[Dict
]
abstract projects()[source]
Get a list of active projects in the organization.
Return type:
List
[RBProject
]
abstract create_workspace(name, exists_okay=False)[source]
Create a workspace within the organization.
This method creates a worspace in a similar fashion to the quickstart on the RedBrick AI create workspace page.
Parameters:
RBProject
abstract delete_project(project_id)[source]
Delete a project by ID.
Return type:
bool
abstract labeling_time(start_date, end_date, concurrency=50)[source]
Get information of tasks labeled between two dates (both inclusive).
Return type:
List
[Dict
]
abstract create_taxonomy(name, study_classify=None, series_classify=None, instance_classify=None, object_types=None)[source]
Create a Taxonomy.
Parameters:
str
) – Unique identifier for the taxonomy.
Optional
[List
[Attribute
]]) – Study level classification applies to the task.
Optional
[List
[Attribute
]]) – Series level classification applies to a single series within a task.
Optional
[List
[Attribute
]]) – Instance classification applies to a single frame (video) or slice (3D volume).
Optional
[List
[ObjectType
]]) – Object types are used to annotate features/objects in tasks, for example, segmentation or bounding boxes.
None
abstract get_taxonomy(name=None, tax_id=None)[source]
Get (fetch, export) a Taxonomy associated with your Organization based on id or name. Useful for reviewing a Taxonomy in RedBrick-proprietary format or modifying a Taxonomy (with update_taxonomy())
Format reference for categories and attributes objects: https://sdk.redbrickai.com/formats/taxonomy.html
Return type:
Taxonomy
abstract update_taxonomy(tax_id, study_classify=None, series_classify=None, instance_classify=None, object_types=None)[source]
Update the categories/attributes of Taxonomy (V2) in the organization.
Format reference for categories and attributes objects: https://sdk.redbrickai.com/formats/taxonomy.html
Raises:
ValueError: – If there are validation errors.
Return type:
None
abstract delete_taxonomy(name=None, tax_id=None)[source]
Delete a taxonomy by name or ID.
Return type:
bool
ABC
Abstract interface to Team module.
abstract get_member(member_id)[source]
Get a team member.
org = redbrick.get_org(org_id, api_key**)**
member = org.team.get_member(member_id)
Parameters:
member_id (str) – Unique member userId or email.
Return type:
OrgMember
abstract list_members()[source]
Get a list of all organization members.
org = redbrick.get_org(org_id, api_key**)**
members = org.team.list_members()
Return type:
List[OrgMember]
abstract remove_members(member_ids)[source]
Remove members from the organization.
org = redbrick.get_org(org_id, api_key**)**
org.team.remove_members(member_ids)
Parameters:
member_ids (List[str]) – Unique member ids (userId or email).
Return type:
None
abstract list_invites()[source]
Get a list of all pending or declined invites.
org = redbrick.get_org(org_id, api_key**)**
members = org.team.list_invites()
Return type:
List[OrgInvite]
abstract invite_user(invitation)[source]
Invite a user to the organization.
org = redbrick.get_org(org_id, api_key**)**
invitation = org.team.invite_user(OrgInvite(email=”…”, role=OrgMember.Role.MEMBER))
Parameters:
invitation (OrgInvite) – Organization invite
Return type:
OrgInvite
abstract revoke_invitation(invitation)[source]
Revoke org user invitation.
org = redbrick.get_org(org_id, api_key**)**
org.team.revoke_invitation(OrgInvite(email=”…”))
Parameters:
invitation (OrgInvite) – Organization invite
Return type:
None
ABC
Storage Method Controller.
abstract get_storage(storage_id)[source]
Get a storage method by ID.
Return type:
StorageProvider
abstract list_storages()[source]
Get a list of storage methods in the organization.
Return type:
List
[StorageProvider
]
abstract create_storage(storage)[source]
Create a storage method.
Return type:
StorageProvider
abstract update_storage(storage_id, details)[source]
Update a storage method.
Return type:
StorageProvider
abstract delete_storage(storage_id)[source]
Delete a storage method.
Return type:
bool
abstract verify_storage(storage_id, path)[source]
Verify a storage method by ID.
Return type:
bool
ABC
Interface for interacting with your RedBrick AI Workspaces.
abstract property org_id: str
Read only property.
Retrieves the unique Organization UUID that this workspace belongs to
abstract property workspace_id: str
Read only property.
Retrieves the unique Workspace ID UUID.
abstract property name: str
Read only name property.
Retrieves the workspace name.
abstract property metadata_schema: List[Dict]
Retrieves the workspace metadata schema.
abstract property classification_schema: List[Dict]
Retrieves the workspace classification schema.
abstract property cohorts: List[Dict]
Retrieves the workspace cohorts.
abstract update_schema(metadata_schema=None, classification_schema=None)[source]
Update workspace metadata and classification schema.
Return type:
None
abstract update_cohorts(cohorts)[source]
Update workspace cohorts.
Return type:
None
abstract get_datapoints(*, concurrency=10)[source]
Get datapoints in a workspace.
Return type:
Iterator
[Dict
]
abstract archive_datapoints(dp_ids)[source]
Archive datapoints.
Return type:
None
abstract unarchive_datapoints(dp_ids)[source]
Unarchive datapoints.
Return type:
None
abstract add_datapoints_to_cohort(cohort_name, dp_ids)[source]
Add datapoints to a cohort.
Return type:
None
abstract remove_datapoints_from_cohort(cohort_name, dp_ids)[source]
Remove datapoints from a cohort.
Return type:
None
abstract update_datapoint_attributes(dp_id, attributes)[source]
Update datapoint attributes.
Return type:
None
abstract add_datapoints_to_projects(project_ids, dp_ids, is_ground_truth=False)[source]
Add datapoints to project.
Parameters:
None
abstract create_datapoints(storage_id, points, *, concurrency=50)[source]
Create datapoints in workspace.
Upload data to your workspace (without annotations). Please visit our documentation to understand the format for points
.
workspace = redbrick.get_workspace(org_id, workspace_id, api_key**,** url)
points = [
{
“name”: ”…”,
“series”: [
{
“items”: ”…”,
}
]
}
]
workspace.create_datapoints(storage_id, points)
Parameters:
InputTask
]) – Please see the RedBrick AI reference documentation for overview of the format. https://sdk.redbrickai.com/formats/index.html#import. Fields with annotation information are not supported in workspace.
redbrick.StorageMethod.REDBRICK
as the storage id. Your items path must be a valid path to a locally stored image.
2. When doing direct upload i.e. redbrick.StorageMethod.REDBRICK
, if you didn’t specify a “name” field in your datapoints object, we will assign the “items” path to it.
abstract update_datapoints_metadata(storage_id, points)[source]
Update datapoints metadata.
Update metadata for datapoints in workspace.
workspace = redbrick.get_workspace(org_id, workspace_id, api_key**,** url)
points = [
{
“dpId”: ”…”,
“metaData”: {
“property”: “value”,
}
}
]
workspace.update_datapoints_metadata(storage_id, points)
Parameters:
InputTask
]) – List of datapoints with dpId and metaData values.
None
abstract delete_datapoints(dp_ids, concurrency=50)[source]
Delete workspace datapoints based on ids.
>>> workspace = redbrick.get_workspace(org_id, workspace_id, api_key**,** url)
>>> workspace.delete_datapoints([…])
Parameters:
ABC
Abstract interface to RBProject.
Variables:
redbrick.StorageMethod.REDBRICK
. Set a custom external storage, within which RedBrick AI will write all annotations.
>>> project = redbrick.get_project(org_id, project_id, api_key**)**
>>> project.set_label_storage(storage_id)
Parameters:
None
ABC
Primary interface for various export methods.
The export module has many functions for exporting annotations and meta-data from projects. The export module is available from the redbrick.RBProject
module.
>>> project = redbrick.get_project(api_key**="",** org_id="", project_id="")
>>> project.export # Export
abstract export_tasks(*, concurrency=10, only_ground_truth=False, stage_name=None, task_id=None, from_timestamp=None, old_format=False, without_masks=False, without_json=False, semantic_mask=False, binary_mask=None, no_consensus=None, with_files=False, dicom_to_nifti=False, png=False, rt_struct=False, mhd=False, destination=None)[source]
Export annotation data.
Meta-data and category information returned as an Object. Segmentations are written to your disk in NIfTI-1 format. Please visit our documentation for more information on the format.
>>> project = redbrick.get_project(org_id, project_id, api_key**,** url)
>>> project.export.export_tasks()
Parameters:
OutputTask
]
Note
If both semantic_mask and binary_mask options are True, then one binary mask will be generated per class.
abstract list_tasks(search=TaskFilters.ALL, concurrency=10, limit=50, *, stage_name=None, user_id=None, task_id=None, task_name=None, exact_match=False, completed_at=None)[source]
Search tasks based on multiple queries for a project. This function returns minimal meta-data about the queried tasks.
>>> project = redbrick.get_project(org_id, project_id, api_key**,** url)
>>> result = project.export.list_tasks()
Parameters:
TaskFilters
= TaskFilters.ALL) – Task filter type.
ABC
Primary interface for uploading to a project.
>>> project = redbrick.get_project(api_key**="",** org_id="", project_id="")
>>> project.upload
abstract create_datapoints(storage_id, points, *, is_ground_truth=False, segmentation_mapping=None, rt_struct=False, mhd=False, label_storage_id=None, label_validate=False, prune_segmentations=False, concurrency=50)[source]
Create datapoints in project.
Upload data, and optionally annotations, to your project. Please visit our documentation to understand the format for points
.
project = redbrick.get_project(org_id, project_id, api_key**,** url)
points = [
{
“name”: ”…”,
“series”: [
{
“items”: ”…”,
# These fields are needed for importing segmentations.
“segmentations”: ”…”,
“segmentMap”: {…}
}
]
}
]
project.upload.create_datapoints(storage_id, points)
Parameters:
InputTask
]) – Please see the RedBrick AI reference documentation for overview of the format. https://sdk.redbrickai.com/formats/index.html#import. All the fields with annotation information are optional.
points
, and this parameters is set to true, the labels will be added to the Ground Truth stage.
redbrick.StorageMethod.REDBRICK
as the storage id. Your items path must be a valid path to a locally stored image.
2. When doing direct upload i.e. redbrick.StorageMethod.REDBRICK
, if you didn’t specify a “name” field in your datapoints object, we will assign the “items” path to it.
abstract delete_tasks(task_ids, concurrency=50)[source]
Delete project tasks based on task ids.
>>> project = redbrick.get_project(org_id, project_id, api_key**,** url)
>>> project.upload.delete_tasks([…])
Parameters:
InputTask
]) – List of objects with taskId and series, where series contains a list of items paths to be updated for the task.
redbrick.StorageMethod.REDBRICK
as the storage id. Your items path must be a valid path to a locally stored image.
abstract import_tasks_from_workspace(source_project_id, task_ids, with_labels=False)[source]
Import tasks from another project in the same workspace.
project = redbrick.get_project(org_id, project_id, api_key**,** url)
project.upload.import_tasks_from_workspace(source_project_id, task_ids)
Parameters:
None
abstract update_tasks_labels(tasks, *, rt_struct=False, mhd=False, label_storage_id=‘22222222-2222-2222-2222-222222222222’, label_validate=False, prune_segmentations=False, concurrency=50, finalize=False, time_spent_ms=None, extra_data=None)[source]
Update tasks labels at any point in project pipeline.
project = redbrick.get_project(…)
tasks = [
{
“taskId”: ”…”,
“series”: [{…}]
},
]
# Overwrite labels in tasks
project.upload.update_tasks_labels(tasks)
Parameters:
OutputTask
]) – Please see the RedBrick AI reference documentation for overview of the format. https://sdk.redbrickai.com/formats/index.html#export. All the fields with annotation information are optional.
None
abstract send_tasks_to_stage(task_ids, stage_name, concurrency=50)[source]
Send tasks to different stage.
Parameters:
None
ABC
Perform programmatic labeling and review tasks.
The Labeling class allows you to programmatically submit tasks. This can be useful for times when you want to make bulk actions e.g accepting several tasks, or make automated actions like using automated methods for review.
Information
The Labeling module provides several methods to query tasks and assign tasks to different users. Refer to this section for guidance on when to use each method:
assign_tasks
. Use this method when you already have the task_ids
you want to assign to a particular user. If you don’t have the task_ids
, you can query the tasks using list_tasks
.task_id
, you can use list_tasks
to get a filtered list of tasks in your project, that you want to work upon.
Label
project = redbrick.get_project(…)
tasks = [
{
“taskId”: ”…”,
“series”: [{…}]
},
]
# Submit tasks with new labels
project.labeling.put_tasks(“Label”, tasks)
# Save tasks with new labels, without submitting
project.labeling.put_tasks(“Label”, tasks, finalize=False)
# Submit tasks with existing labels
project.labeling.put_tasks(“Label”, [{“taskId”:”…”}], existing_labels=True)
Review
Parameters:
OutputTask
]) – Tasks with new labels or review result.
OutputTask
]
abstract assign_tasks(task_ids, *, email=None, emails=None, refresh=True)[source]
Assign tasks to specified email or current API key.
Unassigns all users from the task if neither of the email
or current_user
are set.
>>> project = redbrick.get_project(org_id, project_id, api_key**)**
>>> project.labeling.assign_tasks([task_id], email=email)
Parameters:
task_id
of the tasks you want to assign.
None
ABC
Abstract interface to Settings module.
abstract property label_validation: LabelValidation
Label Validation.
Use custom label validation to prevent annotation errors in real-time. Please visit label validation for more info.
Format: {“enabled”: bool, “enforce”: bool, “script”: str}
Get
project = redbrick.get_project(org_id, project_id, api_key**,** url)
label_validation = project.settings.label_validation
Set
abstract property hanging_protocol: HangingProtocol
Hanging Protocol.
Use hanging protocol to define the visual layout of tool. Please visit hanging protocol for more info.
Format: {“enabled”: bool, “script”: str}
Get
project = redbrick.get_project(org_id, project_id, api_key**,** url)
hanging_protocol = project.settings.hanging_protocol
Set
abstract property webhook: Webhook
Project webhook.
Use webhooks to receive custom events like tasks entering stages, and many more.
Format: {“enabled”: bool, “url”: str}
Get
project = redbrick.get_project(org_id, project_id, api_key**,** url)
webhook = project.settings.webhook
Set
abstract toggle_reference_standard_task(task_id, enable)[source]
Toggle reference standard task.
Return type:
None
abstract property task_duplication: int | None
Sibling task count.
Use task duplication to create multiple tasks for a single uploaded datapoint. Please visit task duplication for more info.
Format: Optional[int]
Get
project = redbrick.get_project(org_id, project_id, api_key**,** url)
count = project.settings.task_duplication
Set
ABC
Abstract interface to Workforce module.
abstract get_member(member_id)[source]
Get a project member.
project = redbrick.get_project(org_id, project_id, api_key**)**
member = project.workforce.get_member(member_id)
Parameters:
member_id (str) – Unique member userId or email.
Return type:
ProjectMember
abstract list_members()[source]
Get a list of all project members.
project = redbrick.get_project(org_id, project_id, api_key**)**
members = project.workforce.list_members()
Return type:
List[ProjectMember]
abstract add_members(members)[source]
Add project members.
project = redbrick.get_project(org_id, project_id, api_key**)**
member = project.workforce.add_members([{“member_id”: ”…”, “role”: ”…”, “stages”: [”…”]}, …])
Parameters:
members (List[ProjectMember]) – List of members to add.
Returns:
List of added project members.
Return type:
List[ProjectMember]
abstract update_members(members)[source]
Update project members.
project = redbrick.get_project(org_id, project_id, api_key**)**
member = project.workforce.update_members([{“member_id”: ”…”, “role”: ”…”, “stages”: [”…”]}, …])
Parameters:
members (List[ProjectMember]) – List of members to update.
Returns:
List of updated project members.
Return type:
List[ProjectMember]
abstract remove_members(member_ids)[source]
Remove project members.
project = redbrick.get_project(org_id, project_id, api_key**)**
member = project.workforce.remove_members([…])
Parameters:
member_ids (List[str]) – List of member ids (user_id/email) to remove from the project.
Return type:
None
NextCommand Line InterfacePreviousHome
Copyright © 2023, RedBrick AI
Made with Sphinx and @pradyunsg’s Furo
On this page
StorageMethod
StorageProvider
ImportTypes
TaskEventTypes
TaskFilters
TaskStates
Stage
LabelStage
ReviewStage
ModelStage
OrgMember
OrgInvite
ProjectMember
get_org()
get_workspace()
get_project()
get_org_from_profile()
get_project_from_profile()
RBOrganization
RBOrganization.org_id
RBOrganization.name
RBOrganization.taxonomies()
RBOrganization.workspaces_raw()
RBOrganization.projects_raw()
RBOrganization.projects()
RBOrganization.create_workspace()
RBOrganization.create_project_advanced()
RBOrganization.create_project()
RBOrganization.get_project()
RBOrganization.delete_project()
RBOrganization.labeling_time()
RBOrganization.create_taxonomy()
RBOrganization.get_taxonomy()
RBOrganization.update_taxonomy()
RBOrganization.delete_taxonomy()
RBWorkspace
RBWorkspace.org_id
RBWorkspace.workspace_id
RBWorkspace.name
RBWorkspace.metadata_schema
RBWorkspace.classification_schema
RBWorkspace.cohorts
RBWorkspace.update_schema()
RBWorkspace.update_cohorts()
RBWorkspace.get_datapoints()
RBWorkspace.archive_datapoints()
RBWorkspace.unarchive_datapoints()
RBWorkspace.add_datapoints_to_cohort()
RBWorkspace.remove_datapoints_from_cohort()
RBWorkspace.update_datapoint_attributes()
RBWorkspace.add_datapoints_to_projects()
RBWorkspace.create_datapoints()
RBWorkspace.update_datapoints_metadata()
RBWorkspace.delete_datapoints()