VersionResource

API Access class for model versions

Source code in src/specklepy/api/resources/current/version_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(version_id: str, project_id: str) -> Version

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

def get(self, version_id: str, project_id: str) -> Version:
    QUERY = gql(
        """
        query VersionGet($projectId: String!, $versionId: String!) {
          data:project(id: $projectId) {
            data:version(id: $versionId) {
              id
              referencedObject
              message
              sourceApplication
              createdAt
              previewUrl
              authorUser {
                id
                name
                bio
                company
                verified
                role
                avatar
              }
            }
          }
        }
        """
    )

    variables = {
        "projectId": project_id,
        "versionId": version_id,
    }

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

get_versions

get_versions(
    model_id: str,
    project_id: str,
    *,
    limit: int = 25,
    cursor: Optional[str] = None,
    filter: Optional[ModelVersionsFilter] = None,
) -> ResourceCollection[Version]

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

def get_versions(
    self,
    model_id: str,
    project_id: str,
    *,
    limit: int = 25,
    cursor: Optional[str] = None,
    filter: Optional[ModelVersionsFilter] = None,
) -> ResourceCollection[Version]:
    QUERY = gql(
        """
        query VersionGetVersions(
          $projectId: String!,
          $modelId: String!,
          $limit: Int!,
          $cursor: String,
          $filter: ModelVersionsFilter
          ) {
          data:project(id: $projectId) {
            data:model(id: $modelId) {
              data:versions(limit: $limit, cursor: $cursor, filter: $filter) {
                items {
                  id
                  referencedObject
                  message
                  sourceApplication
                  createdAt
                  previewUrl
                  authorUser {
                    id
                    name
                    bio
                    company
                    verified
                    role
                    avatar
                  }
                }
                cursor
                totalCount
              }
            }
          }
        }
        """
    )

    variables = {
        "projectId": project_id,
        "modelId": model_id,
        "limit": limit,
        "cursor": cursor,
        "filter": (
            filter.model_dump(warnings="error", by_alias=True) if filter else None
        ),
    }

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

create

create(input: CreateVersionInput) -> Version

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

def create(self, input: CreateVersionInput) -> Version:
    QUERY = gql(
        """
        mutation Create($input: CreateVersionInput!) {
          data:versionMutations {
            data:create(input: $input) {
              id
              referencedObject
              message
              sourceApplication
              createdAt
              previewUrl
              authorUser {
                id
                name
                bio
                company
                verified
                role
                avatar
              }
            }
          }
        }
        """
    )
    variables = {
        "input": input.model_dump(warnings="error", by_alias=True),
    }

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

update

update(input: UpdateVersionInput) -> Version

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

def update(self, input: UpdateVersionInput) -> Version:
    QUERY = gql(
        """
        mutation VersionUpdate($input: UpdateVersionInput!) {
          data:versionMutations {
            data:update(input: $input) {
              id
              referencedObject
              message
              sourceApplication
              createdAt
              previewUrl
              authorUser {
                id
                name
                bio
                company
                verified
                role
                avatar
              }
            }
          }
        }
        """
    )

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

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

move_to_model

move_to_model(input: MoveVersionsInput) -> str

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

def move_to_model(self, input: MoveVersionsInput) -> str:
    QUERY = gql(
        """
        mutation VersionMoveToModel($input: MoveVersionsInput!) {
          data:versionMutations {
            data:moveToModel(input: $input) {
              data:id
            }
          }
        }
        """
    )

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

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

delete

delete(input: DeleteVersionsInput) -> bool

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

def delete(self, input: DeleteVersionsInput) -> bool:
    QUERY = gql(
        """
        mutation VersionDelete($input: DeleteVersionsInput!) {
          data:versionMutations {
            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

received

received(input: MarkReceivedVersionInput) -> bool

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

def received(self, input: MarkReceivedVersionInput) -> bool:
    QUERY = gql(
        """
        mutation MarkReceived($input: MarkReceivedVersionInput!) {
          data:versionMutations {
            data:markReceived(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