ModelResource

API Access class for models

Source code in src/specklepy/api/resources/current/model_resource.py

def __init__(self, account, basepath, client, server_version) -> None:
    super().__init__(
        account=account,
        basepath=basepath,
        client=client,
        name=NAME,
        server_version=server_version,
    )

get

get(model_id: str, project_id: str) -> Model

Source code in src/specklepy/api/resources/current/model_resource.py

def get(self, model_id: str, project_id: str) -> Model:
    QUERY = gql(
        """
        query ModelGet($modelId: String!, $projectId: String!) {
          data:project(id: $projectId) {
            data:model(id: $modelId) {
              id
              name
              previewUrl
              updatedAt
              description
              displayName
              createdAt
              author {
                avatar
                bio
                company
                id
                name
                role
                verified
              }
            }
          }
        }
        """
    )

    variables = {
        "modelId": model_id,
        "projectId": project_id,
    }

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[Model]], QUERY, variables
    ).data.data

get_with_versions

get_with_versions(
    model_id: str,
    project_id: str,
    *,
    versions_limit: int = 25,
    versions_cursor: Optional[str] = None,
    versions_filter: Optional[ModelVersionsFilter] = None,
) -> ModelWithVersions

Source code in src/specklepy/api/resources/current/model_resource.py

def get_with_versions(
    self,
    model_id: str,
    project_id: str,
    *,
    versions_limit: int = 25,
    versions_cursor: Optional[str] = None,
    versions_filter: Optional[ModelVersionsFilter] = None,
) -> ModelWithVersions:
    QUERY = gql(
        """
        query ModelGetWithVersions(
          $modelId: String!,
          $projectId: String!,
          $versionsLimit: Int!,
          $versionsCursor: String,
          $versionsFilter: ModelVersionsFilter
          ) {
          data:project(id: $projectId) {
            data:model(id: $modelId) {
              id
              name
              previewUrl
              updatedAt
              versions(
                limit: $versionsLimit,
                cursor: $versionsCursor,
                filter: $versionsFilter
                ) {
                items {
                  id
                  referencedObject
                  message
                  sourceApplication
                  createdAt
                  previewUrl
                  authorUser {
                    avatar
                    id
                    name
                    bio
                    company
                    verified
                    role
                  }
                }
                totalCount
                cursor
              }
              description
              displayName
              createdAt
              author {
                avatar
                bio
                company
                id
                name
                role
                verified
              }
            }
          }
        }
        """
    )

    variables = {
        "projectId": project_id,
        "modelId": model_id,
        "versionsLimit": versions_limit,
        "versionsCursor": versions_cursor,
        "versionsFilter": (
            versions_filter.model_dump(warnings="error", by_alias=True)
            if versions_filter
            else None
        ),
    }

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[ModelWithVersions]], QUERY, variables
    ).data.data

get_models

get_models(
    project_id: str,
    *,
    models_limit: int = 25,
    models_cursor: Optional[str] = None,
    models_filter: Optional[ProjectModelsFilter] = None,
) -> ResourceCollection[Model]

Source code in src/specklepy/api/resources/current/model_resource.py

def get_models(
    self,
    project_id: str,
    *,
    models_limit: int = 25,
    models_cursor: Optional[str] = None,
    models_filter: Optional[ProjectModelsFilter] = None,
) -> ResourceCollection[Model]:
    QUERY = gql(
        """
        query ProjectGetWithModels(
          $projectId: String!,
          $modelsLimit: Int!,
          $modelsCursor: String,
          $modelsFilter: ProjectModelsFilter
          ) {
          data:project(id: $projectId) {
            data:models(
              limit: $modelsLimit,
              cursor: $modelsCursor,
              filter: $modelsFilter
              ) {
              items {
                id
                name
                previewUrl
                updatedAt
                displayName
                description
                createdAt
                author {
                  avatar
                  bio
                  company
                  id
                  name
                  role
                  verified
                }
              }
              totalCount
              cursor
            }
          }
        }
        """
    )

    variables = {
        "projectId": project_id,
        "modelsLimit": models_limit,
        "modelsCursor": models_cursor,
        "modelsFilter": (
            models_filter.model_dump(warnings="error", by_alias=True)
            if models_filter
            else None
        ),
    }

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[ResourceCollection[Model]]], QUERY, variables
    ).data.data

create

create(input: CreateModelInput) -> Model

Source code in src/specklepy/api/resources/current/model_resource.py

def create(self, input: CreateModelInput) -> Model:
    QUERY = gql(
        """
        mutation ModelCreate($input: CreateModelInput!) {
          data:modelMutations {
            data:create(input: $input) {
              id
              displayName
              name
              description
              createdAt
              updatedAt
              previewUrl
              author {
                avatar
                bio
                company
                id
                name
                role
                verified
              }
            }
          }
        }
        """
    )

    variables = {
        "input": input.model_dump(warnings="error", by_alias=True),
    }

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[Model]], QUERY, variables
    ).data.data

delete

delete(input: DeleteModelInput) -> bool

Source code in src/specklepy/api/resources/current/model_resource.py

def delete(self, input: DeleteModelInput) -> bool:
    QUERY = gql(
        """
        mutation ModelDelete($input: DeleteModelInput!) {
          data:modelMutations {
            data:delete(input: $input)
          }
        }
        """
    )

    variables = {"input": input.model_dump(warnings="error", by_alias=True)}

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[bool]], QUERY, variables
    ).data.data

update

update(input: UpdateModelInput) -> Model

Source code in src/specklepy/api/resources/current/model_resource.py

def update(self, input: UpdateModelInput) -> Model:
    QUERY = gql(
        """
        mutation ModelUpdate($input: UpdateModelInput!) {
          data:modelMutations {
            data:update(input: $input) {
              id
              name
              displayName
              description
              createdAt
              updatedAt
              previewUrl
              author {
                avatar
                bio
                company
                id
                name
                role
                verified
              }
            }
          }
        }
        """
    )

    variables = {
        "input": input.model_dump(warnings="error", by_alias=True),
    }

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[Model]], QUERY, variables
    ).data.data

get_permissions

get_permissions(
    project_id: str, model_id: str
) -> ModelPermissionChecks

Source code in src/specklepy/api/resources/current/model_resource.py

def get_permissions(self, project_id: str, model_id: str) -> ModelPermissionChecks:
    QUERY = gql(
        """
        query ModelPermissions($projectId: String!, $modelId: String!) {
          data:project(id: $projectId) {
            data:model(id: $modelId) {
              data:permissions {
                canUpdate {
                  authorized
                  code
                  message
                }
                canDelete {
                  authorized
                  code
                  message
                }
                canCreateVersion {
                  authorized
                  code
                  message
                }
              }
            }
          }
        }
        """
    )

    variables = {"projectId": project_id, "modelId": model_id}

    return self.make_request_and_parse_response(
        DataResponse[DataResponse[DataResponse[ModelPermissionChecks]]],
        QUERY,
        variables,
    ).data.data.data

can_create_model_ingestion

can_create_model_ingestion(
    project_id: str, model_id: str
) -> PermissionCheckResult

Source code in src/specklepy/api/resources/current/model_resource.py

def can_create_model_ingestion(
    self, project_id: str, model_id: str
) -> PermissionCheckResult:
    QUERY = gql(
        """
        query ModelPermissions($projectId: String!, $modelId: String!) {
          data:project(id: $projectId) {
            data:model(id: $modelId) {
              data:permissions {
                data:canCreateIngestion {
                  authorized
                  code
                  message
                }
              }
            }
          }
        }
        """
    )

    variables = {"projectId": project_id, "modelId": model_id}

    return self.make_request_and_parse_response(
        DataResponse[
            DataResponse[DataResponse[DataResponse[PermissionCheckResult]]]
        ],
        QUERY,
        variables,
    ).data.data.data.data